refactor

README.md

@@ -138,10 +138,10 @@ DataSource dataSource = new ShardingDataSource(shardingRule);
 String sql = "SELECT i.* FROM t_order o JOIN t_order_item i ON o.order_id=i.order_id WHERE o.user_id=? AND o.order_id=?";
 try (
         Connection conn = dataSource.getConnection();
-        PreparedStatement pstmt = conn.prepareStatement(sql)) {
-    pstmt.setInt(1, 10);
-    pstmt.setInt(2, 1001);
-    try (ResultSet rs = pstmt.executeQuery()) {
+        PreparedStatement preparedStatement = conn.prepareStatement(sql)) {
+    preparedStatement.setInt(1, 10);
+    preparedStatement.setInt(2, 1001);
+    try (ResultSet rs = preparedStatement.executeQuery()) {
         while(rs.next()) {
             System.out.println(rs.getInt(1));
             System.out.println(rs.getInt(2));

pom.xml

@@ -480,6 +480,7 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-javadoc-plugin</artifactId>
+                <version>${maven-javadoc-plugin.version}</version>
                 <configuration>
                     <aggregate>true</aggregate>
                     <charset>${project.build.sourceEncoding}</charset>
@@ -546,7 +547,7 @@
     
     <repositories>
         <repository>
-            <id>henryyan-mavenrepo</id>
+            <id>alfresco-maven-repo</id>
             <url>https://maven.alfresco.com/nexus/content/groups/public/</url>
         </repository>
         <repository>
@@ -575,7 +576,7 @@
     <description>RDB Sharding</description>
     <licenses>
         <license>
-            <name>Apache Licene 2.0</name>
+            <name>Apache License 2.0</name>
             <url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
             <distribution>repo</distribution>
         </license>

sharding-jdbc-config-parent/sharding-jdbc-config-spring/src/main/java/com/dangdang/ddframe/rdb/sharding/spring/namespace/parser/ShardingJdbcDataSourceBeanDefinitionParser.java

@@ -78,9 +78,9 @@ public class ShardingJdbcDataSourceBeanDefinitionParser extends AbstractBeanDefi
     
     private Map<String, BeanDefinition> parseTableRulesConfig(final Element element) {
         Element tableRulesElement = DomUtils.getChildElementByTagName(element, ShardingJdbcDataSourceBeanDefinitionParserTag.TABLE_RULES_TAG);
-        List<Element> tableRulelements = DomUtils.getChildElementsByTagName(tableRulesElement, ShardingJdbcDataSourceBeanDefinitionParserTag.TABLE_RULE_TAG);
-        Map<String, BeanDefinition> result = new ManagedMap<>(tableRulelements.size());
-        for (Element each : tableRulelements) {
+        List<Element> tableRuleElements = DomUtils.getChildElementsByTagName(tableRulesElement, ShardingJdbcDataSourceBeanDefinitionParserTag.TABLE_RULE_TAG);
+        Map<String, BeanDefinition> result = new ManagedMap<>(tableRuleElements.size());
+        for (Element each : tableRuleElements) {
             result.put(each.getAttribute(ShardingJdbcDataSourceBeanDefinitionParserTag.LOGIC_TABLE_ATTR), parseTableRuleConfig(each));
         }
         return result;

sharding-jdbc-config-parent/sharding-jdbc-config-spring/src/test/java/com/dangdang/ddframe/rdb/sharding/spring/AbstractShardingBothDataBasesAndTablesSpringDBUnitTest.java

@@ -27,7 +27,7 @@ import java.sql.SQLException;
 public abstract class AbstractShardingBothDataBasesAndTablesSpringDBUnitTest extends AbstractSpringDBUnitTest {
     
     @Test
-    public void testWithAllPlacehloders() throws SQLException {
+    public void testWithAllPlaceholders() throws SQLException {
         insertData();
         selectData();
     }
@@ -38,28 +38,28 @@ public abstract class AbstractShardingBothDataBasesAndTablesSpringDBUnitTest ext
         for (int orderId = 1; orderId <= 4; orderId++) {
             for (int userId = 1; userId <= 2; userId++) {
                 try (Connection connection = getShardingDataSource().getConnection()) {
-                    PreparedStatement pstmt = connection.prepareStatement(orderSql);
-                    pstmt.setInt(1, orderId);
-                    pstmt.setInt(2, userId);
-                    pstmt.setString(3, "insert");
-                    pstmt.execute();
-                    pstmt.close();
+                    PreparedStatement preparedStatement = connection.prepareStatement(orderSql);
+                    preparedStatement.setInt(1, orderId);
+                    preparedStatement.setInt(2, userId);
+                    preparedStatement.setString(3, "insert");
+                    preparedStatement.execute();
+                    preparedStatement.close();
                     
-                    pstmt = connection.prepareStatement(orderItemSql);
-                    pstmt.setInt(1, orderId);
-                    pstmt.setInt(2, orderId);
-                    pstmt.setInt(3, userId);
-                    pstmt.setString(4, "insert");
-                    pstmt.execute();
-                    pstmt.close();
+                    preparedStatement = connection.prepareStatement(orderItemSql);
+                    preparedStatement.setInt(1, orderId);
+                    preparedStatement.setInt(2, orderId);
+                    preparedStatement.setInt(3, userId);
+                    preparedStatement.setString(4, "insert");
+                    preparedStatement.execute();
+                    preparedStatement.close();
                     
-                    pstmt = connection.prepareStatement(orderItemSql);
-                    pstmt.setInt(1, orderId + 4);
-                    pstmt.setInt(2, orderId);
-                    pstmt.setInt(3, userId);
-                    pstmt.setString(4, "insert");
-                    pstmt.execute();
-                    pstmt.close();
+                    preparedStatement = connection.prepareStatement(orderItemSql);
+                    preparedStatement.setInt(1, orderId + 4);
+                    preparedStatement.setInt(2, orderId);
+                    preparedStatement.setInt(3, userId);
+                    preparedStatement.setString(4, "insert");
+                    preparedStatement.execute();
+                    preparedStatement.close();
                 }
             }
         }
@@ -69,14 +69,14 @@ public abstract class AbstractShardingBothDataBasesAndTablesSpringDBUnitTest ext
         String sql = "SELECT i.order_id, i.order_item_id  FROM `t_order` o JOIN `t_order_item` i ON o.user_id = i.user_id AND o.order_id = i.order_id"
             + " WHERE o.`user_id` = %s AND o.`order_id` = %s ORDER BY i.order_item_id DESC";
         try (Connection connection = getShardingDataSource().getConnection()) {
-            PreparedStatement pstmt = connection.prepareStatement(String.format(sql, 10, 1000));
-            ResultSet resultSet = pstmt.executeQuery();
+            PreparedStatement preparedStatement = connection.prepareStatement(String.format(sql, 10, 1000));
+            ResultSet resultSet = preparedStatement.executeQuery();
             while (resultSet.next()) {
                 int order_id = resultSet.getInt(1);
                 int order_item_id = resultSet.getInt(2);
                 System.out.println(order_id+","+order_item_id);
             }
-            pstmt.close();
+            preparedStatement.close();
         }
     }
 }

sharding-jdbc-config-parent/sharding-jdbc-config-spring/src/test/java/com/dangdang/ddframe/rdb/sharding/spring/AbstractSpringDBUnitTest.java

@@ -45,7 +45,7 @@ public abstract class AbstractSpringDBUnitTest extends AbstractJUnit4SpringConte
     @Getter
     private ShardingDataSource shardingDataSource;
     
-    private ClassLoader classLoader = AbstractSpringDBUnitTest.class.getClassLoader();
+    private final ClassLoader classLoader = AbstractSpringDBUnitTest.class.getClassLoader();
     
     @Before
     public void createSchema() throws SQLException {

sharding-jdbc-core/src/main/java/com/dangdang/ddframe/rdb/sharding/jdbc/ShardingConnection.java

@@ -52,7 +52,7 @@ public final class ShardingConnection extends AbstractConnectionAdapter {
     @Getter(AccessLevel.PACKAGE)
     private final ShardingContext shardingContext;
     
-    private Map<String, Connection> connectionMap = new HashMap<>();
+    private final Map<String, Connection> connectionMap = new HashMap<>();
     
     /**
      * 根据数据源名称获取相应的数据库连接.
@@ -67,7 +67,7 @@ public final class ShardingConnection extends AbstractConnectionAdapter {
         Context metricsContext = MetricsContext.start("ShardingConnection-getConnection", dataSourceName);
         Connection connection = shardingContext.getShardingRule().getDataSourceRule().getDataSource(dataSourceName).getConnection();
         MetricsContext.stop(metricsContext);
-        replayMethodsInvovation(connection);
+        replayMethodsInvocation(connection);
         connectionMap.put(dataSourceName, connection);
         return connection;
     }

sharding-jdbc-core/src/main/java/com/dangdang/ddframe/rdb/sharding/jdbc/ShardingPreparedStatement.java

@@ -168,7 +168,7 @@ public final class ShardingPreparedStatement extends AbstractPreparedStatementAd
         setMergeContext(mergeContext);
         for (SQLExecutionUnit each : sqlRouteResult.getExecutionUnits()) {
             PreparedStatement preparedStatement = generatePrepareStatement(getShardingConnection().getConnection(each.getDataSource()), each.getSql());
-            replayMethodsInvovation(preparedStatement);
+            replayMethodsInvocation(preparedStatement);
             setParameters(preparedStatement, parameters);
             result.add(new PreparedStatementExecutorWrapper(preparedStatement, parameters, each));
         }

sharding-jdbc-core/src/main/java/com/dangdang/ddframe/rdb/sharding/jdbc/ShardingStatement.java

@@ -71,15 +71,15 @@ public class ShardingStatement extends AbstractStatementAdapter {
     @Setter(AccessLevel.PROTECTED)
     private ResultSet currentResultSet;
     
-    public ShardingStatement(final ShardingConnection shardingConnection) throws SQLException {
+    public ShardingStatement(final ShardingConnection shardingConnection) {
         this(shardingConnection, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, ResultSet.HOLD_CURSORS_OVER_COMMIT);
     }
     
-    public ShardingStatement(final ShardingConnection shardingConnection, final int resultSetType, final int resultSetConcurrency) throws SQLException {
+    public ShardingStatement(final ShardingConnection shardingConnection, final int resultSetType, final int resultSetConcurrency) {
         this(shardingConnection, resultSetType, resultSetConcurrency, ResultSet.HOLD_CURSORS_OVER_COMMIT);
     }
     
-    public ShardingStatement(final ShardingConnection shardingConnection, final int resultSetType, final int resultSetConcurrency, final int resultSetHoldability) throws SQLException {
+    public ShardingStatement(final ShardingConnection shardingConnection, final int resultSetType, final int resultSetConcurrency, final int resultSetHoldability) {
         super(Statement.class);
         this.shardingConnection = shardingConnection;
         this.resultSetType = resultSetType;
@@ -164,7 +164,7 @@ public class ShardingStatement extends AbstractStatementAdapter {
         } else {
             result = connection.createStatement(resultSetType, resultSetConcurrency, resultSetHoldability);
         }
-        replayMethodsInvovation(result);
+        replayMethodsInvocation(result);
         cachedRoutedStatements.put(hashCode, result);
         return result;
     }

sharding-jdbc-core/src/main/java/com/dangdang/ddframe/rdb/sharding/jdbc/adapter/AbstractPreparedStatementAdapter.java

@@ -51,8 +51,7 @@ public abstract class AbstractPreparedStatementAdapter extends AbstractUnsupport
     @Getter
     private final List<Object> parameters = new ArrayList<>();
     
-    public AbstractPreparedStatementAdapter(final ShardingConnection shardingConnection, 
-            final int resultSetType, final int resultSetConcurrency, final int resultSetHoldability) throws SQLException {
+    protected AbstractPreparedStatementAdapter(final ShardingConnection shardingConnection, final int resultSetType, final int resultSetConcurrency, final int resultSetHoldability) throws SQLException {
         super(shardingConnection, resultSetType, resultSetConcurrency, resultSetHoldability);
     }
     

sharding-jdbc-core/src/main/java/com/dangdang/ddframe/rdb/sharding/jdbc/adapter/AbstractStatementAdapter.java

@@ -156,7 +156,7 @@ public abstract class AbstractStatementAdapter extends AbstractUnsupportedOperat
      * @return 路由的静态语句对象集合
      * @throws SQLException
      */
-    public abstract Collection<? extends Statement> getRoutedStatements() throws SQLException;
+    protected abstract Collection<? extends Statement> getRoutedStatements() throws SQLException;
     
     /**
      *  清除路由的静态语句对象集合.

sharding-jdbc-core/src/main/java/com/dangdang/ddframe/rdb/sharding/jdbc/adapter/WrapperAdapter.java

@@ -32,7 +32,7 @@ import com.dangdang.ddframe.rdb.sharding.jdbc.util.JdbcMethodInvocation;
  */
 public class WrapperAdapter implements Wrapper {
     
-    private Collection<JdbcMethodInvocation> jdbcMethodInvocations = new ArrayList<>();
+    private final Collection<JdbcMethodInvocation> jdbcMethodInvocations = new ArrayList<>();
     
     @SuppressWarnings("unchecked")
     @Override
@@ -69,7 +69,7 @@ public class WrapperAdapter implements Wrapper {
      * 
      * @param target 目标对象
      */
-    protected final void replayMethodsInvovation(final Object target) {
+    protected final void replayMethodsInvocation(final Object target) {
         for (JdbcMethodInvocation each : jdbcMethodInvocations) {
             each.invoke(target);
         }

sharding-jdbc-core/src/main/java/com/dangdang/ddframe/rdb/sharding/jdbc/unsupported/AbstractUnsupportedOperationPreparedStatement.java

@@ -37,8 +37,7 @@ import com.dangdang.ddframe.rdb.sharding.jdbc.ShardingStatement;
  */
 public abstract class AbstractUnsupportedOperationPreparedStatement extends ShardingStatement implements PreparedStatement {
     
-    public AbstractUnsupportedOperationPreparedStatement(final ShardingConnection shardingConnection, 
-            final int resultSetType, final int resultSetConcurrency, final int resultSetHoldability) throws SQLException {
+    protected AbstractUnsupportedOperationPreparedStatement(final ShardingConnection shardingConnection, final int resultSetType, final int resultSetConcurrency, final int resultSetHoldability) {
         super(shardingConnection, resultSetType, resultSetConcurrency, resultSetHoldability);
     }
     

sharding-jdbc-core/src/main/java/com/dangdang/ddframe/rdb/sharding/merger/aggregation/AggregationInvokeHandler.java

@@ -64,7 +64,7 @@ public final class AggregationInvokeHandler extends AbstractMergerInvokeHandler<
             final ResultSetQueryIndex resultSetQueryIndex, final AggregationColumn aggregationColumn) 
             throws SQLException {
         AggregationUnit unit = AggregationUnitFactory.create(aggregationColumn.getAggregationType(), returnType);
-        for (ResultSet each : aggregationResultSet.getEffectivedResultSets()) {
+        for (ResultSet each : aggregationResultSet.getEffectiveResultSets()) {
             unit.merge(aggregationColumn, new ResultSetAggregationValue(each), resultSetQueryIndex);
         }
         return unit.getResult();

sharding-jdbc-core/src/main/java/com/dangdang/ddframe/rdb/sharding/merger/aggregation/AggregationResultSet.java

@@ -38,7 +38,7 @@ import lombok.Getter;
 @Getter
 public final class AggregationResultSet extends AbstractShardingResultSet {
     
-    private final Collection<ResultSet> effectivedResultSets;
+    private final Collection<ResultSet> effectiveResultSets;
     
     private final List<AggregationColumn> aggregationColumns;
     
@@ -47,7 +47,7 @@ public final class AggregationResultSet extends AbstractShardingResultSet {
     public AggregationResultSet(final List<ResultSet> resultSets, final MergeContext mergeContext) {
         super(resultSets, mergeContext.getLimit());
         aggregationColumns = mergeContext.getAggregationColumns();
-        effectivedResultSets = new LinkedHashSet<>(resultSets.size());
+        effectiveResultSets = new LinkedHashSet<>(resultSets.size());
     }
     
     @Override
@@ -58,11 +58,11 @@ public final class AggregationResultSet extends AbstractShardingResultSet {
         }
         for (ResultSet each : getResultSets()) {
             if (!each.next()) {
-                effectivedResultSets.remove(each);
+                effectiveResultSets.remove(each);
                 continue;
             }
-            effectivedResultSets.add(each);
+            effectiveResultSets.add(each);
         }
-        return !effectivedResultSets.isEmpty();
+        return !effectiveResultSets.isEmpty();
     }
 }

sharding-jdbc-core/src/main/java/com/dangdang/ddframe/rdb/sharding/merger/common/AbstractMergerInvokeHandler.java

@@ -52,6 +52,6 @@ public abstract class AbstractMergerInvokeHandler<T extends AbstractShardingResu
     protected abstract Object doMerge(T resultSet, Method method, ResultSetQueryIndex resultSetQueryIndex) throws ReflectiveOperationException, SQLException;
     
     protected Object invokeOriginal(final Method method, final ResultSetQueryIndex resultSetQueryIndex) throws ReflectiveOperationException {
-        return method.invoke(resultSet, new Object[] {resultSetQueryIndex.getRawQueryIndex()});
+        return method.invoke(resultSet, resultSetQueryIndex.getRawQueryIndex());
     }
 }

sharding-jdbc-core/src/main/java/com/dangdang/ddframe/rdb/sharding/merger/groupby/GroupByResultSet.java

@@ -111,7 +111,7 @@ public final class GroupByResultSet extends AbstractShardingResultSet {
         }
     }
     
-    private Multimap<GroupByKey, GroupByValue> map() throws SQLException {
+    private Multimap<GroupByKey, GroupByValue> map() {
         ExecuteUnit<ResultSet, Map<GroupByKey, GroupByValue>> executeUnit = new ExecuteUnit<ResultSet, Map<GroupByKey, GroupByValue>>() {
             
             @Override

sharding-jdbc-core/src/main/java/com/dangdang/ddframe/rdb/sharding/merger/orderby/OrderByResultSet.java

@@ -35,47 +35,47 @@ public final class OrderByResultSet extends AbstractShardingResultSet {
     
     private final List<OrderByColumn> orderByColumns;
     
-    private final List<ResultSet> effectivedResultSets;
+    private final List<ResultSet> effectiveResultSets;
     
     private boolean initial;
     
     public OrderByResultSet(final List<ResultSet> resultSets, final MergeContext mergeContext) {
         super(resultSets, mergeContext.getLimit());
         orderByColumns = mergeContext.getOrderByColumns();
-        effectivedResultSets = new ArrayList<>(resultSets.size());
+        effectiveResultSets = new ArrayList<>(resultSets.size());
     }
     
     @Override
     public boolean nextForSharding() throws SQLException {
         if (!initial) {
-            initialEffectivedResultSets();
+            initialEffectiveResultSets();
         } else {
-            nextEffectivedResultSets();
+            nextEffectiveResultSets();
         }
-        OrderByValue choosenOrderByValue = null;
-        for (ResultSet each : effectivedResultSets) {
+        OrderByValue chosenOrderByValue = null;
+        for (ResultSet each : effectiveResultSets) {
             OrderByValue eachOrderByValue = new OrderByValue(orderByColumns, each);
-            if (null == choosenOrderByValue || choosenOrderByValue.compareTo(eachOrderByValue) > 0) {
-                choosenOrderByValue = eachOrderByValue;
+            if (null == chosenOrderByValue || chosenOrderByValue.compareTo(eachOrderByValue) > 0) {
+                chosenOrderByValue = eachOrderByValue;
                 setCurrentResultSet(each);
             }
         }
-        return !effectivedResultSets.isEmpty();
+        return !effectiveResultSets.isEmpty();
     }
     
-    private void initialEffectivedResultSets() throws SQLException {
+    private void initialEffectiveResultSets() throws SQLException {
         for (ResultSet each : getResultSets()) {
             if (each.next()) {
-                effectivedResultSets.add(each);
+                effectiveResultSets.add(each);
             }
         }
         initial = true;
     }
     
-    private void nextEffectivedResultSets() throws SQLException {
+    private void nextEffectiveResultSets() throws SQLException {
         boolean next = getCurrentResultSet().next();
         if (!next) {
-            effectivedResultSets.remove(getCurrentResultSet());
+            effectiveResultSets.remove(getCurrentResultSet());
         }
     }
 }

sharding-jdbc-core/src/main/java/com/dangdang/ddframe/rdb/sharding/metrics/ThreadLocalObjectContainer.java

@@ -33,7 +33,7 @@ public final class ThreadLocalObjectContainer {
     
     private static final ThreadLocal<Map<String, Object>> THREAD_LOCAL_CONTAINER = new ThreadLocal<>();
     
-    private Map<String, Object> data = new HashMap<>();
+    private final Map<String, Object> data = new HashMap<>();
     
     /**
      * 向容器内添加初始对象.

sharding-jdbc-core/src/main/java/com/dangdang/ddframe/rdb/sharding/parser/visitor/ParseContext.java

@@ -18,7 +18,6 @@
 package com.dangdang.ddframe.rdb.sharding.parser.visitor;
 
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashSet;
@@ -105,18 +104,18 @@ public final class ParseContext {
      * 
      * @param expr SQL表达式
      * @param operator 操作符
-     * @param valueExprs 值对象表达式集合
+     * @param valueExprList 值对象表达式集合
      * @param databaseType 数据库类型
-     * @param paramters 通过占位符传进来的参数
+     * @param parameters 通过占位符传进来的参数
      */
-    public void addCondition(final SQLExpr expr, final BinaryOperator operator, final List<SQLExpr> valueExprs, final DatabaseType databaseType, final List<Object> paramters) {
+    public void addCondition(final SQLExpr expr, final BinaryOperator operator, final List<SQLExpr> valueExprList, final DatabaseType databaseType, final List<Object> parameters) {
         Optional<Column> column = getColumn(expr);
         if (!column.isPresent()) {
             return;
         }
-        List<Comparable<?>> values = new ArrayList<>(valueExprs.size());
-        for (SQLExpr each : valueExprs) {
-            Comparable<?> evalValue = evalExpression(databaseType, each, paramters);
+        List<Comparable<?>> values = new ArrayList<>(valueExprList.size());
+        for (SQLExpr each : valueExprList) {
+            Comparable<?> evalValue = evalExpression(databaseType, each, parameters);
             if (null != evalValue) {
                 values.add(evalValue);
             }
@@ -135,10 +134,10 @@ public final class ParseContext {
      * @param operator 操作符
      * @param valueExpr 值对象表达式
      * @param databaseType 数据库类型
-     * @param paramters 通过占位符传进来的参数
+     * @param parameters 通过占位符传进来的参数
      */
-    public void addCondition(final String columnName, final String tableName, final BinaryOperator operator, final SQLExpr valueExpr, final DatabaseType databaseType, final List<Object> paramters) {
-        Comparable<?> value = evalExpression(databaseType, valueExpr, paramters);
+    public void addCondition(final String columnName, final String tableName, final BinaryOperator operator, final SQLExpr valueExpr, final DatabaseType databaseType, final List<Object> parameters) {
+        Comparable<?> value = evalExpression(databaseType, valueExpr, parameters);
         if (null != value) {
             addCondition(createColumn(columnName, tableName), operator, Collections.<Comparable<?>>singletonList(value));
         }
@@ -195,8 +194,8 @@ public final class ParseContext {
         return null != currentTable ? createColumn(expr.getName(), currentTable.getName()) : null;
     }
     
-    private Column createColumn(final String columName, final String tableName) {
-        return new Column(SQLUtil.getExactlyValue(columName), SQLUtil.getExactlyValue(tableName));
+    private Column createColumn(final String columnName, final String tableName) {
+        return new Column(SQLUtil.getExactlyValue(columnName), SQLUtil.getExactlyValue(tableName));
     }
     
     private Optional<Table> findTable(final String tableNameOrAlias) {

sharding-jdbc-core/src/main/java/com/dangdang/ddframe/rdb/sharding/parser/visitor/VisitorLogProxy.java

@@ -64,7 +64,7 @@ public final class VisitorLogProxy {
     
     private static class VisitorHandler implements MethodInterceptor {
         
-        private StringBuilder hierarchyIndex = new StringBuilder();
+        private final StringBuilder hierarchyIndex = new StringBuilder();
         
         private Integer depth = 0;
         

sharding-jdbc-core/src/main/java/com/dangdang/ddframe/rdb/sharding/parser/visitor/basic/mysql/AbstractMySQLVisitor.java

@@ -47,7 +47,7 @@ public abstract class AbstractMySQLVisitor extends MySqlOutputVisitor implements
     
     private final ParseContext parseContext = new ParseContext();
     
-    public AbstractMySQLVisitor() {
+    protected AbstractMySQLVisitor() {
         super(new SQLBuilder());
         setPrettyFormat(false);
     }

sharding-jdbc-core/src/main/java/com/dangdang/ddframe/rdb/sharding/parser/visitor/or/node/AbstractOrASTNode.java

@@ -36,9 +36,9 @@ import lombok.Getter;
 @Getter(AccessLevel.PROTECTED)
 public abstract class AbstractOrASTNode {
     
-    private List<AbstractOrASTNode> subNodes = new ArrayList<>();
+    private final List<AbstractOrASTNode> subNodes = new ArrayList<>();
     
-    private List<List<Condition>> nestedConditions = new ArrayList<>();
+    private final List<List<Condition>> nestedConditions = new ArrayList<>();
     
     public final void addSubNode(final AbstractOrASTNode node) {
         subNodes.add(node);

sharding-jdbc-core/src/main/java/com/dangdang/ddframe/rdb/sharding/parser/visitor/or/node/CompositeOrASTNode.java

@@ -33,7 +33,7 @@ import lombok.Getter;
 @Getter
 public class CompositeOrASTNode extends AbstractOrASTNode {
     
-    private List<Condition> outConditions = new ArrayList<>();
+    private final List<Condition> outConditions = new ArrayList<>();
     
     public void addOutConditions(final ConditionContext outConditions) {
         this.outConditions.addAll(outConditions.getAllConditions());

sharding-jdbc-core/src/main/java/com/dangdang/ddframe/rdb/sharding/router/mixed/MixedTablesRouter.java

@@ -52,7 +52,7 @@ public class MixedTablesRouter {
      * 
      * @return 路由结果
      */
-    // TODO 支持多bindtable rule
+    // TODO 支持多bindingTable rule
     public RoutingResult route() {
         Collection<String> bindingTables = shardingRule.filterAllBindingTables(logicTables);
         Collection<String> remainingTables = new ArrayList<>(logicTables);

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/integrate/AbstractDBUnitTest.java

@@ -46,7 +46,7 @@ import static org.dbunit.Assertion.assertEquals;
 
 public abstract class AbstractDBUnitTest {
     
-    public static final DatabaseType CURRENT_DB_TYPE = DatabaseType.H2;
+    protected static final DatabaseType CURRENT_DB_TYPE = DatabaseType.H2;
     
     private static final Map<String, DataSource> DATA_SOURCES = new HashMap<>();
     
@@ -131,7 +131,7 @@ public abstract class AbstractDBUnitTest {
         }
     }
     
-    private IDatabaseConnection getConnection(final Connection connection) throws SQLException, DatabaseUnitException {
+    private IDatabaseConnection getConnection(final Connection connection) throws DatabaseUnitException {
         switch (dbEnv.getDatabaseType()) {
             case H2: 
                 return new H2Connection(connection, "PUBLIC");

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/integrate/db/AbstractShardingDataBasesOnlyDBUnitTest.java

@@ -34,7 +34,7 @@ import java.util.List;
 
 public abstract class AbstractShardingDataBasesOnlyDBUnitTest extends AbstractDBUnitTest {
     
-    private String dataSourceName = "dataSource_%s";
+    private final String dataSourceName = "dataSource_%s";
     
     @Override
     protected List<String> getSchemaFiles() {
@@ -66,7 +66,7 @@ public abstract class AbstractShardingDataBasesOnlyDBUnitTest extends AbstractDB
                 "integrate/dataset/db/init/db_9.xml");
     }
     
-    protected final ShardingDataSource getShardingDataSource() throws SQLException {
+    protected final ShardingDataSource getShardingDataSource() {
         DataSourceRule dataSourceRule = new DataSourceRule(createDataSourceMap(dataSourceName));
         TableRule orderTableRule = new TableRule("t_order", Collections.singletonList("t_order"), dataSourceRule);
         TableRule orderItemTableRule = new TableRule("t_order_item", Collections.singletonList("t_order_item"), dataSourceRule);

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/integrate/db/DMLShardingDataBasesOnlyTest.java

@@ -39,56 +39,56 @@ public final class DMLShardingDataBasesOnlyTest extends AbstractShardingDataBase
     }
     
     @Test
-    public void assertInsertWithAllPlacehloders() throws SQLException, DatabaseUnitException {
+    public void assertInsertWithAllPlaceholders() throws SQLException, DatabaseUnitException {
         String sql = "INSERT INTO `t_order` (`order_id`, `user_id`, `status`) VALUES (?, ?, ?)";
         for (int i = 1; i <= 10; i++) {
             try (Connection connection = shardingDataSource.getConnection()) {
-                PreparedStatement pstmt = connection.prepareStatement(sql);
-                pstmt.setInt(1, i);
-                pstmt.setInt(2, i);
-                pstmt.setString(3, "insert");
-                pstmt.executeUpdate();
+                PreparedStatement preparedStatement = connection.prepareStatement(sql);
+                preparedStatement.setInt(1, i);
+                preparedStatement.setInt(2, i);
+                preparedStatement.setString(3, "insert");
+                preparedStatement.executeUpdate();
             }
         }
-        assertDataset("insert", "insert");
+        assertDataSet("insert", "insert");
     }
     
     @Test
-    public void assertInsertWithoutPlacehloder() throws SQLException, DatabaseUnitException {
+    public void assertInsertWithoutPlaceholder() throws SQLException, DatabaseUnitException {
         String sql = "INSERT INTO `t_order` (`order_id`, `user_id`, `status`) VALUES (%s, %s, 'insert')";
         for (int i = 1; i <= 10; i++) {
             try (Connection connection = shardingDataSource.getConnection()) {
-                PreparedStatement pstmt = connection.prepareStatement(String.format(sql, i, i));
-                pstmt.executeUpdate();
+                PreparedStatement preparedStatement = connection.prepareStatement(String.format(sql, i, i));
+                preparedStatement.executeUpdate();
             }
         }
-        assertDataset("insert", "insert");
+        assertDataSet("insert", "insert");
     }
     
     @Test
-    public void assertInsertWithPlacehlodersForShardingKeys() throws SQLException, DatabaseUnitException {
+    public void assertInsertWithPlaceholdersForShardingKeys() throws SQLException, DatabaseUnitException {
         String sql = "INSERT INTO `t_order` (`order_id`, `user_id`, `status`) VALUES (%s, %s, ?)";
         for (int i = 1; i <= 10; i++) {
             try (Connection connection = shardingDataSource.getConnection()) {
-                PreparedStatement pstmt = connection.prepareStatement(String.format(sql, i, i));
-                pstmt.setString(1, "insert");
-                pstmt.executeUpdate();
+                PreparedStatement preparedStatement = connection.prepareStatement(String.format(sql, i, i));
+                preparedStatement.setString(1, "insert");
+                preparedStatement.executeUpdate();
             }
         }
-        assertDataset("insert", "insert");
+        assertDataSet("insert", "insert");
     }
     
     @Test
-    public void assertInsertWithPlacehlodersForNotShardingKeys() throws SQLException, DatabaseUnitException {
+    public void assertInsertWithPlaceholdersForNotShardingKeys() throws SQLException, DatabaseUnitException {
         String sql = "INSERT INTO `t_order` (`order_id`, `user_id`, `status`) VALUES (%s, %s, ?)";
         for (int i = 1; i <= 10; i++) {
             try (Connection connection = shardingDataSource.getConnection()) {
-                PreparedStatement pstmt = connection.prepareStatement(String.format(sql, i, i));
-                pstmt.setString(1, "insert");
-                pstmt.executeUpdate();
+                PreparedStatement preparedStatement = connection.prepareStatement(String.format(sql, i, i));
+                preparedStatement.setString(1, "insert");
+                preparedStatement.executeUpdate();
             }
         }
-        assertDataset("insert", "insert");
+        assertDataSet("insert", "insert");
     }
     
     @Test
@@ -97,15 +97,15 @@ public final class DMLShardingDataBasesOnlyTest extends AbstractShardingDataBase
         for (int i = 10; i < 30; i++) {
             for (int j = 0; j < 2; j++) {
                 try (Connection connection = shardingDataSource.getConnection()) {
-                    PreparedStatement pstmt = connection.prepareStatement(sql);
-                    pstmt.setString(1, "updated");
-                    pstmt.setInt(2, i * 100 + j);
-                    pstmt.setInt(3, i);
-                    assertThat(pstmt.executeUpdate(), is(1));
+                    PreparedStatement preparedStatement = connection.prepareStatement(sql);
+                    preparedStatement.setString(1, "updated");
+                    preparedStatement.setInt(2, i * 100 + j);
+                    preparedStatement.setInt(3, i);
+                    assertThat(preparedStatement.executeUpdate(), is(1));
                 }
             }
         }
-        assertDataset("update", "updated");
+        assertDataSet("update", "updated");
     }
     
     @Test
@@ -114,27 +114,27 @@ public final class DMLShardingDataBasesOnlyTest extends AbstractShardingDataBase
         for (int i = 10; i < 30; i++) {
             for (int j = 0; j < 2; j++) {
                 try (Connection connection = shardingDataSource.getConnection()) {
-                    PreparedStatement pstmt = connection.prepareStatement(sql);
-                    pstmt.setString(1, "updated");
-                    pstmt.setInt(2, i * 100 + j);
-                    pstmt.setInt(3, i);
-                    assertThat(pstmt.executeUpdate(), is(1));
+                    PreparedStatement preparedStatement = connection.prepareStatement(sql);
+                    preparedStatement.setString(1, "updated");
+                    preparedStatement.setInt(2, i * 100 + j);
+                    preparedStatement.setInt(3, i);
+                    assertThat(preparedStatement.executeUpdate(), is(1));
                 }
             }
         }
-        assertDataset("update", "updated");
+        assertDataSet("update", "updated");
     }
     
     @Test
     public void assertUpdateWithoutShardingValue() throws SQLException, DatabaseUnitException {
         String sql = "UPDATE `t_order` SET `status` = ? WHERE `status` = ?";
         try (Connection connection = shardingDataSource.getConnection()) {
-            PreparedStatement pstmt = connection.prepareStatement(sql);
-            pstmt.setString(1, "updated");
-            pstmt.setString(2, "init");
-            assertThat(pstmt.executeUpdate(), is(40));
+            PreparedStatement preparedStatement = connection.prepareStatement(sql);
+            preparedStatement.setString(1, "updated");
+            preparedStatement.setString(2, "init");
+            assertThat(preparedStatement.executeUpdate(), is(40));
         }
-        assertDataset("update", "updated");
+        assertDataSet("update", "updated");
     }
     
     @Test
@@ -143,29 +143,29 @@ public final class DMLShardingDataBasesOnlyTest extends AbstractShardingDataBase
         for (int i = 10; i < 30; i++) {
             for (int j = 0; j < 2; j++) {
                 try (Connection connection = shardingDataSource.getConnection()) {
-                    PreparedStatement pstmt = connection.prepareStatement(sql);
-                    pstmt.setInt(1, i * 100 + j);
-                    pstmt.setInt(2, i);
-                    pstmt.setString(3, "init");
-                    assertThat(pstmt.executeUpdate(), is(1));
+                    PreparedStatement preparedStatement = connection.prepareStatement(sql);
+                    preparedStatement.setInt(1, i * 100 + j);
+                    preparedStatement.setInt(2, i);
+                    preparedStatement.setString(3, "init");
+                    assertThat(preparedStatement.executeUpdate(), is(1));
                 }
             }
         }
-        assertDataset("delete", "init");
+        assertDataSet("delete", "init");
     }
     
     @Test
     public void assertDeleteWithoutShardingValue() throws SQLException, DatabaseUnitException {
         String sql = "DELETE `t_order` WHERE `status` = ?";
         try (Connection connection = shardingDataSource.getConnection()) {
-            PreparedStatement pstmt = connection.prepareStatement(sql);
-            pstmt.setString(1, "init");
-            assertThat(pstmt.executeUpdate(), is(40));
+            PreparedStatement preparedStatement = connection.prepareStatement(sql);
+            preparedStatement.setString(1, "init");
+            assertThat(preparedStatement.executeUpdate(), is(40));
         }
-        assertDataset("delete", "init");
+        assertDataSet("delete", "init");
     }
     
-    private void assertDataset(final String expectedDataSetPattern, final String status) throws SQLException, DatabaseUnitException {
+    private void assertDataSet(final String expectedDataSetPattern, final String status) throws SQLException, DatabaseUnitException {
         for (int i = 0; i < 10; i++) {
             assertDataSet(String.format("integrate/dataset/db/expect/%s/db_%s.xml", expectedDataSetPattern, i), 
                     shardingDataSource.getConnection().getConnection(String.format("dataSource_db_%s", i)), "t_order", "SELECT * FROM `t_order` WHERE `status`=?", status);

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/integrate/db/StatementDMLShardingDataBasesOnlyTest.java

@@ -49,7 +49,7 @@ public class StatementDMLShardingDataBasesOnlyTest extends AbstractShardingDataB
                 connection.close();
             }
         }
-        assertDataset("insert", "insert");
+        assertDataSet("insert", "insert");
     }
     
     @Test
@@ -62,7 +62,7 @@ public class StatementDMLShardingDataBasesOnlyTest extends AbstractShardingDataB
                 }
             }
         }
-        assertDataset("update", "updated");
+        assertDataSet("update", "updated");
     }
     
     @Test
@@ -71,7 +71,7 @@ public class StatementDMLShardingDataBasesOnlyTest extends AbstractShardingDataB
             Statement stmt = connection.createStatement();
             assertThat(stmt.executeUpdate(String.format("UPDATE `t_order` SET `status` = '%s' WHERE `status` = '%s'", "updated", "init")), is(40));
         }
-        assertDataset("update", "updated");
+        assertDataSet("update", "updated");
     }
     
     @Test
@@ -84,7 +84,7 @@ public class StatementDMLShardingDataBasesOnlyTest extends AbstractShardingDataB
                 }
             }
         }
-        assertDataset("delete", "init");
+        assertDataSet("delete", "init");
     }
     
     @Test
@@ -93,10 +93,10 @@ public class StatementDMLShardingDataBasesOnlyTest extends AbstractShardingDataB
             Statement stmt = connection.createStatement();
             assertThat(stmt.executeUpdate(String.format("DELETE `t_order` WHERE `status` = '%s'", "init")), is(40));
         }
-        assertDataset("delete", "init");
+        assertDataSet("delete", "init");
     }
     
-    private void assertDataset(final String expectedDataSetPattern, final String status) throws SQLException, DatabaseUnitException {
+    private void assertDataSet(final String expectedDataSetPattern, final String status) throws SQLException, DatabaseUnitException {
         for (int i = 0; i < 10; i++) {
             assertDataSet(String.format("integrate/dataset/db/expect/%s/db_%s.xml", expectedDataSetPattern, i),
                     shardingDataSource.getConnection().getConnection(String.format("dataSource_db_%s", i)), "t_order", "SELECT * FROM `t_order` WHERE `status`=?", status);

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/integrate/dbtbl/AbstractShardingBothDataBasesAndTablesDBUnitTest.java

@@ -34,7 +34,7 @@ import java.util.List;
 
 public abstract class AbstractShardingBothDataBasesAndTablesDBUnitTest extends AbstractDBUnitTest {
     
-    private String dataSourceName = "dataSource_%s";
+    private final String dataSourceName = "dataSource_%s";
     
     @Override
     protected List<String> getSchemaFiles() {
@@ -66,7 +66,7 @@ public abstract class AbstractShardingBothDataBasesAndTablesDBUnitTest extends A
                 "integrate/dataset/dbtbl/init/dbtbl_9.xml");
     }
     
-    protected final ShardingDataSource getShardingDataSource() throws SQLException {
+    protected final ShardingDataSource getShardingDataSource() {
         DataSourceRule dataSourceRule = new DataSourceRule(createDataSourceMap(dataSourceName));
         TableRule orderTableRule = new TableRule("t_order", Arrays.asList(
                 "t_order_0", 

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/integrate/dbtbl/DMLShardingBothDataBasesAndTablesTest.java

@@ -40,64 +40,64 @@ public final class DMLShardingBothDataBasesAndTablesTest extends AbstractShardin
     }
     
     @Test
-    public void assertInsertWithAllPlacehloders() throws SQLException, DatabaseUnitException {
+    public void assertInsertWithAllPlaceholders() throws SQLException, DatabaseUnitException {
         String sql = "INSERT INTO `t_order` (`order_id`, `user_id`, `status`) VALUES (?, ?, ?)";
         for (int i = 1; i <= 10; i++) {
             for (int j = 1; j <= 10; j++) {
                 try (Connection connection = shardingDataSource.getConnection()) {
-                    PreparedStatement pstmt = connection.prepareStatement(sql);
-                    pstmt.setInt(1, i);
-                    pstmt.setInt(2, j);
-                    pstmt.setString(3, "insert");
-                    pstmt.executeUpdate();
+                    PreparedStatement preparedStatement = connection.prepareStatement(sql);
+                    preparedStatement.setInt(1, i);
+                    preparedStatement.setInt(2, j);
+                    preparedStatement.setString(3, "insert");
+                    preparedStatement.executeUpdate();
                 }
             }
         }
-        assertDataset("insert", "insert");
+        assertDataSet("insert", "insert");
     }
     
     @Test
-    public void assertInsertWithoutPlacehloder() throws SQLException, DatabaseUnitException {
+    public void assertInsertWithoutPlaceholder() throws SQLException, DatabaseUnitException {
         String sql = "INSERT INTO `t_order` (`order_id`, `user_id`, `status`) VALUES (%s, %s, 'insert')";
         for (int i = 1; i <= 10; i++) {
             for (int j = 1; j <= 10; j++) {
                 try (Connection connection = shardingDataSource.getConnection()) {
-                    PreparedStatement pstmt = connection.prepareStatement(String.format(sql, i, j));
-                    pstmt.executeUpdate();
+                    PreparedStatement preparedStatement = connection.prepareStatement(String.format(sql, i, j));
+                    preparedStatement.executeUpdate();
                 }
             }
         }
-        assertDataset("insert", "insert");
+        assertDataSet("insert", "insert");
     }
     
     @Test
-    public void assertInsertWithPlacehlodersForShardingKeys() throws SQLException, DatabaseUnitException {
+    public void assertInsertWithPlaceholdersForShardingKeys() throws SQLException, DatabaseUnitException {
         String sql = "INSERT INTO `t_order` (`order_id`, `user_id`, `status`) VALUES (%s, %s, ?)";
         for (int i = 1; i <= 10; i++) {
             for (int j = 1; j <= 10; j++) {
                 try (Connection connection = shardingDataSource.getConnection()) {
-                    PreparedStatement pstmt = connection.prepareStatement(String.format(sql, i, j));
-                    pstmt.setString(1, "insert");
-                    pstmt.executeUpdate();
+                    PreparedStatement preparedStatement = connection.prepareStatement(String.format(sql, i, j));
+                    preparedStatement.setString(1, "insert");
+                    preparedStatement.executeUpdate();
                 }
             }
         }
-        assertDataset("insert", "insert");
+        assertDataSet("insert", "insert");
     }
     
     @Test
-    public void assertInsertWithPlacehlodersForNotShardingKeys() throws SQLException, DatabaseUnitException {
+    public void assertInsertWithPlaceholdersForNotShardingKeys() throws SQLException, DatabaseUnitException {
         String sql = "INSERT INTO `t_order` (`order_id`, `user_id`, `status`) VALUES (%s, %s, ?)";
         for (int i = 1; i <= 10; i++) {
             for (int j = 1; j <= 10; j++) {
                 try (Connection connection = shardingDataSource.getConnection()) {
-                    PreparedStatement pstmt = connection.prepareStatement(String.format(sql, i, j));
-                    pstmt.setString(1, "insert");
-                    pstmt.executeUpdate();
+                    PreparedStatement preparedStatement = connection.prepareStatement(String.format(sql, i, j));
+                    preparedStatement.setString(1, "insert");
+                    preparedStatement.executeUpdate();
                 }
             }
         }
-        assertDataset("insert", "insert");
+        assertDataSet("insert", "insert");
     }
     
     @Test
@@ -106,15 +106,15 @@ public final class DMLShardingBothDataBasesAndTablesTest extends AbstractShardin
         for (int i = 10; i < 20; i++) {
             for (int j = 0; j < 10; j++) {
                 try (Connection connection = shardingDataSource.getConnection()) {
-                    PreparedStatement pstmt = connection.prepareStatement(sql);
-                    pstmt.setString(1, "updated");
-                    pstmt.setInt(2, i * 100 + j);
-                    pstmt.setInt(3, i);
-                    assertThat(pstmt.executeUpdate(), is(1));
+                    PreparedStatement preparedStatement = connection.prepareStatement(sql);
+                    preparedStatement.setString(1, "updated");
+                    preparedStatement.setInt(2, i * 100 + j);
+                    preparedStatement.setInt(3, i);
+                    assertThat(preparedStatement.executeUpdate(), is(1));
                 }
             }
         }
-        assertDataset("update", "updated");
+        assertDataSet("update", "updated");
     }
     
     @Test
@@ -123,27 +123,27 @@ public final class DMLShardingBothDataBasesAndTablesTest extends AbstractShardin
         for (int i = 10; i < 20; i++) {
             for (int j = 0; j < 10; j++) {
                 try (Connection connection = shardingDataSource.getConnection()) {
-                    PreparedStatement pstmt = connection.prepareStatement(sql);
-                    pstmt.setString(1, "updated");
-                    pstmt.setInt(2, i * 100 + j);
-                    pstmt.setInt(3, i);
-                    assertThat(pstmt.executeUpdate(), is(1));
+                    PreparedStatement preparedStatement = connection.prepareStatement(sql);
+                    preparedStatement.setString(1, "updated");
+                    preparedStatement.setInt(2, i * 100 + j);
+                    preparedStatement.setInt(3, i);
+                    assertThat(preparedStatement.executeUpdate(), is(1));
                 }
             }
         }
-        assertDataset("update", "updated");
+        assertDataSet("update", "updated");
     }
     
     @Test
     public void assertUpdateWithoutShardingValue() throws SQLException, DatabaseUnitException {
         String sql = "UPDATE `t_order` SET `status` = ? WHERE `status` = ?";
         try (Connection connection = shardingDataSource.getConnection()) {
-            PreparedStatement pstmt = connection.prepareStatement(sql);
-            pstmt.setString(1, "updated");
-            pstmt.setString(2, "init");
-            assertThat(pstmt.executeUpdate(), is(100));
+            PreparedStatement preparedStatement = connection.prepareStatement(sql);
+            preparedStatement.setString(1, "updated");
+            preparedStatement.setString(2, "init");
+            assertThat(preparedStatement.executeUpdate(), is(100));
         }
-        assertDataset("update", "updated");
+        assertDataSet("update", "updated");
     }
     
     @Test
@@ -152,28 +152,28 @@ public final class DMLShardingBothDataBasesAndTablesTest extends AbstractShardin
         for (int i = 10; i < 20; i++) {
             for (int j = 0; j < 10; j++) {
                 try (Connection connection = shardingDataSource.getConnection()) {
-                    PreparedStatement pstmt = connection.prepareStatement(sql);
-                    pstmt.setInt(1, i * 100 + j);
-                    pstmt.setInt(2, i);
-                    assertThat(pstmt.executeUpdate(), is(1));
+                    PreparedStatement preparedStatement = connection.prepareStatement(sql);
+                    preparedStatement.setInt(1, i * 100 + j);
+                    preparedStatement.setInt(2, i);
+                    assertThat(preparedStatement.executeUpdate(), is(1));
                 }
             }
         }
-        assertDataset("delete", "init");
+        assertDataSet("delete", "init");
     }
     
     @Test
     public void assertDeleteWithoutShardingValue() throws SQLException, DatabaseUnitException {
         String sql = "DELETE `t_order` WHERE `status` = ?";
         try (Connection connection = shardingDataSource.getConnection()) {
-            PreparedStatement pstmt = connection.prepareStatement(sql);
-            pstmt.setString(1, "init");
-            assertThat(pstmt.executeUpdate(), is(100));
+            PreparedStatement preparedStatement = connection.prepareStatement(sql);
+            preparedStatement.setString(1, "init");
+            assertThat(preparedStatement.executeUpdate(), is(100));
         }
-        assertDataset("delete", "init");
+        assertDataSet("delete", "init");
     }
     
-    private void assertDataset(final String expectedDataSetPattern, final String status) throws SQLException, DatabaseUnitException {
+    private void assertDataSet(final String expectedDataSetPattern, final String status) throws SQLException, DatabaseUnitException {
         for (int i = 0; i < 10; i++) {
             for (int j = 0; j < 10; j++) {
                 assertDataSet(String.format("integrate/dataset/dbtbl/expect/%s/dbtbl_%s.xml", expectedDataSetPattern, i),

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/integrate/dbtbl/SelectShardingBothDataBasesAndTablesTest.java

@@ -96,10 +96,10 @@ public final class SelectShardingBothDataBasesAndTablesTest extends AbstractShar
     }
     
     @Test
-    public void assertSelectWithBingdingTableAndConfigTable() throws SQLException, DatabaseUnitException {
+    public void assertSelectWithBindingTableAndConfigTable() throws SQLException, DatabaseUnitException {
         String sql = "SELECT i.* FROM `t_order` o JOIN `t_order_item` i ON o.user_id = i.user_id AND o.order_id = i.order_id JOIN t_config c ON o.status = c.status"
                 + " WHERE o.`user_id` IN (?, ?) AND o.`order_id` BETWEEN ? AND ? AND c.status = ? ORDER BY i.item_id";
-        assertDataSet("integrate/dataset/dbtbl/expect/select/SelectWithBingdingTableAndConfigTable.xml", shardingDataSource.getConnection(), "t_order_item", sql, 10, 11, 1009, 1108, "init");
+        assertDataSet("integrate/dataset/dbtbl/expect/select/SelectWithBindingTableAndConfigTable.xml", shardingDataSource.getConnection(), "t_order_item", sql, 10, 11, 1009, 1108, "init");
         assertDataSet("integrate/dataset/Empty.xml", shardingDataSource.getConnection(), "t_order_item", sql, 10, 11, 1009, 1108, "none");
     }
     

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/integrate/dbtbl/StatementDMLShardingBothDataBasesAndTablesTest.java

@@ -50,7 +50,7 @@ public final class StatementDMLShardingBothDataBasesAndTablesTest extends Abstra
                 }
             }
         }
-        assertDataset("insert", "insert");
+        assertDataSet("insert", "insert");
     }
     
     @Test
@@ -64,7 +64,7 @@ public final class StatementDMLShardingBothDataBasesAndTablesTest extends Abstra
                 }
             }
         }
-        assertDataset("update", "updated");
+        assertDataSet("update", "updated");
     }
     
     @Test
@@ -74,7 +74,7 @@ public final class StatementDMLShardingBothDataBasesAndTablesTest extends Abstra
             Statement stmt = connection.prepareStatement(sql);
             assertThat(stmt.executeUpdate(String.format(sql, "updated", "init")), is(100));
         }
-        assertDataset("update", "updated");
+        assertDataSet("update", "updated");
     }
     
     
@@ -89,7 +89,7 @@ public final class StatementDMLShardingBothDataBasesAndTablesTest extends Abstra
                 }
             }
         }
-        assertDataset("delete", "init");
+        assertDataSet("delete", "init");
     }
     
     @Test
@@ -99,10 +99,10 @@ public final class StatementDMLShardingBothDataBasesAndTablesTest extends Abstra
             Statement stmt = connection.prepareStatement(sql);
             assertThat(stmt.executeUpdate(String.format(sql, "init")), is(100));
         }
-        assertDataset("delete", "init");
+        assertDataSet("delete", "init");
     }
     
-    private void assertDataset(final String expectedDataSetPattern, final String status) throws SQLException, DatabaseUnitException {
+    private void assertDataSet(final String expectedDataSetPattern, final String status) throws SQLException, DatabaseUnitException {
         for (int i = 0; i < 10; i++) {
             for (int j = 0; j < 10; j++) {
                 assertDataSet(String.format("integrate/dataset/dbtbl/expect/%s/dbtbl_%s.xml", expectedDataSetPattern, i), 

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/integrate/dbtbl/StatementSelectShardingBothDataBasesAndTablesTest.java

@@ -81,10 +81,10 @@ public final class StatementSelectShardingBothDataBasesAndTablesTest extends Abs
     }
     
     @Test
-    public void assertSelectWithBingdingTableAndConfigTable() throws SQLException, DatabaseUnitException {
+    public void assertSelectWithBindingTableAndConfigTable() throws SQLException, DatabaseUnitException {
         String sql = "SELECT i.* FROM `t_order` o JOIN `t_order_item` i ON o.user_id = i.user_id AND o.order_id = i.order_id JOIN t_config c ON o.status = c.status"
                 + " WHERE o.`user_id` IN (%s, %s) AND o.`order_id` BETWEEN %s AND %s AND c.status = '%s' ORDER BY i.item_id";
-        assertDataSet("integrate/dataset/dbtbl/expect/select/SelectWithBingdingTableAndConfigTable.xml", 
+        assertDataSet("integrate/dataset/dbtbl/expect/select/SelectWithBindingTableAndConfigTable.xml", 
                 shardingDataSource.getConnection(), "t_order_item", String.format(sql, 10, 11, 1009, 1108, "init"));
         assertDataSet("integrate/dataset/Empty.xml", shardingDataSource.getConnection(), "t_order_item", String.format(sql, 10, 11, 1009, 1108, "none"));
     }

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/integrate/fixture/MultipleKeysModuloDatabaseShardingAlgorithm.java

@@ -56,7 +56,7 @@ public final class MultipleKeysModuloDatabaseShardingAlgorithm implements Multip
     
     private Collection<String> doInSharding(final Collection<String> availableTargetNames, final ShardingValue<Integer> shardingValue) {
         Collection<String> result = new LinkedHashSet<>(availableTargetNames.size());
-        Collection<Integer> values = (Collection<Integer>) shardingValue.getValues();
+        Collection<Integer> values = shardingValue.getValues();
         for (Integer value : values) {
             for (String dataSourceName : availableTargetNames) {
                 if (dataSourceName.endsWith(value % 10 + "")) {
@@ -69,7 +69,7 @@ public final class MultipleKeysModuloDatabaseShardingAlgorithm implements Multip
     
     private Collection<String> doBetweenSharding(final Collection<String> availableTargetNames, final ShardingValue<Integer> shardingValue) {
         Collection<String> result = new LinkedHashSet<>(availableTargetNames.size());
-        Range<Integer> range = (Range<Integer>) shardingValue.getValueRange();
+        Range<Integer> range = shardingValue.getValueRange();
         for (Integer i = range.lowerEndpoint(); i <= range.upperEndpoint(); i++) {
             for (String each : availableTargetNames) {
                 if (each.endsWith(i % 10 + "")) {

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/integrate/fixture/SingleKeyModuloDatabaseShardingAlgorithm.java

@@ -52,7 +52,7 @@ public final class SingleKeyModuloDatabaseShardingAlgorithm implements SingleKey
     @Override
     public Collection<String> doBetweenSharding(final Collection<String> availableTargetNames, final ShardingValue<Integer> shardingValue) {
         Collection<String> result = new LinkedHashSet<>(availableTargetNames.size());
-        Range<Integer> range = (Range<Integer>) shardingValue.getValueRange();
+        Range<Integer> range = shardingValue.getValueRange();
         for (Integer i = range.lowerEndpoint(); i <= range.upperEndpoint(); i++) {
             for (String each : availableTargetNames) {
                 if (each.endsWith(i % 10 + "")) {

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/integrate/hint/AbstractShardingDataBasesOnlyHintDBUnitTest.java

@@ -39,7 +39,7 @@ import org.dbunit.DatabaseUnitException;
 
 public abstract class AbstractShardingDataBasesOnlyHintDBUnitTest extends AbstractDBUnitTest {
     
-    private String dataSourceName = "dataSource_%s";
+    private final String dataSourceName = "dataSource_%s";
     
     @Override
     protected List<String> getSchemaFiles() {
@@ -71,7 +71,7 @@ public abstract class AbstractShardingDataBasesOnlyHintDBUnitTest extends Abstra
                 "integrate/dataset/db/init/db_9.xml");
     }
     
-    protected final ShardingDataSource getShardingDataSource() throws SQLException {
+    protected final ShardingDataSource getShardingDataSource() {
         DataSourceRule dataSourceRule = new DataSourceRule(createDataSourceMap(dataSourceName));
         TableRule orderTableRule = new TableRule("t_order", Collections.singletonList("t_order"), dataSourceRule);
         TableRule orderItemTableRule = new TableRule("t_order_item", Collections.singletonList("t_order_item"), dataSourceRule);
@@ -81,16 +81,16 @@ public abstract class AbstractShardingDataBasesOnlyHintDBUnitTest extends Abstra
         return new ShardingDataSource(shardingRule);
     }
     
-    protected void assertDataset(final String expectedDataSetFile, final DynamicShardingValueHelper helper, final Connection connection, final String actualTableName, final String sql, final Object... params)
+    protected void assertDataSet(final String expectedDataSetFile, final DynamicShardingValueHelper helper, final Connection connection, final String actualTableName, final String sql, final Object... params)
             throws SQLException, DatabaseUnitException {
-        try (DynamicShardingValueHelper annotherHelper = helper) {
+        try (DynamicShardingValueHelper anotherHelper = helper) {
             assertDataSet(expectedDataSetFile, connection, actualTableName, sql, params);
         }
     }
     
-    protected void assertDataset(final String expectedDataSetFile, final DynamicShardingValueHelper helper, final Connection connection, final String actualTableName, final String sql)
+    protected void assertDataSet(final String expectedDataSetFile, final DynamicShardingValueHelper helper, final Connection connection, final String actualTableName, final String sql)
             throws SQLException, DatabaseUnitException {
-        try (DynamicShardingValueHelper annotherHelper = helper) {
+        try (DynamicShardingValueHelper anotherHelper = helper) {
             assertDataSet(expectedDataSetFile, connection, actualTableName, sql);
         }
     }

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/integrate/hint/DMLShardingDataBasesOnlyHintTest.java

@@ -39,60 +39,60 @@ public final class DMLShardingDataBasesOnlyHintTest extends AbstractShardingData
     }
     
     @Test
-    public void assertInsertWithAllPlacehloders() throws SQLException, DatabaseUnitException {
+    public void assertInsertWithAllPlaceholders() throws SQLException, DatabaseUnitException {
         String sql = "INSERT INTO `t_order` VALUES (?, ?, ?)";
         for (int i = 1; i <= 10; i++) {
             try (DynamicShardingValueHelper helper = new DynamicShardingValueHelper(i, i);
                  Connection connection = shardingDataSource.getConnection()) {
-                PreparedStatement pstmt = connection.prepareStatement(sql);
-                pstmt.setInt(1, i);
-                pstmt.setInt(2, i);
-                pstmt.setString(3, "insert");
-                pstmt.executeUpdate();
+                PreparedStatement preparedStatement = connection.prepareStatement(sql);
+                preparedStatement.setInt(1, i);
+                preparedStatement.setInt(2, i);
+                preparedStatement.setString(3, "insert");
+                preparedStatement.executeUpdate();
             }
         }
-        assertDataset("insert", "insert");
+        assertDataSet("insert", "insert");
     }
     
     @Test
-    public void assertInsertWithoutPlacehloder() throws SQLException, DatabaseUnitException {
+    public void assertInsertWithoutPlaceholder() throws SQLException, DatabaseUnitException {
         String sql = "INSERT INTO `t_order` VALUES (%s, %s, 'insert')";
         for (int i = 1; i <= 10; i++) {
             try (DynamicShardingValueHelper helper = new DynamicShardingValueHelper(i, i);
                  Connection connection = shardingDataSource.getConnection()) {
-                PreparedStatement pstmt = connection.prepareStatement(String.format(sql, i, i));
-                pstmt.executeUpdate();
+                PreparedStatement preparedStatement = connection.prepareStatement(String.format(sql, i, i));
+                preparedStatement.executeUpdate();
             }
         }
-        assertDataset("insert", "insert");
+        assertDataSet("insert", "insert");
     }
     
     @Test
-    public void assertInsertWithPlacehlodersForShardingKeys() throws SQLException, DatabaseUnitException {
+    public void assertInsertWithPlaceholdersForShardingKeys() throws SQLException, DatabaseUnitException {
         String sql = "INSERT INTO `t_order` VALUES (%s, %s, ?)";
         for (int i = 1; i <= 10; i++) {
             try (DynamicShardingValueHelper helper = new DynamicShardingValueHelper(i, i);
                  Connection connection = shardingDataSource.getConnection()) {
-                PreparedStatement pstmt = connection.prepareStatement(String.format(sql, i, i));
-                pstmt.setString(1, "insert");
-                pstmt.executeUpdate();
+                PreparedStatement preparedStatement = connection.prepareStatement(String.format(sql, i, i));
+                preparedStatement.setString(1, "insert");
+                preparedStatement.executeUpdate();
             }
         }
-        assertDataset("insert", "insert");
+        assertDataSet("insert", "insert");
     }
     
     @Test
-    public void assertInsertWithPlacehlodersForNotShardingKeys() throws SQLException, DatabaseUnitException {
+    public void assertInsertWithPlaceholdersForNotShardingKeys() throws SQLException, DatabaseUnitException {
         String sql = "INSERT INTO `t_order` VALUES (%s, %s, ?)";
         for (int i = 1; i <= 10; i++) {
             try (DynamicShardingValueHelper helper = new DynamicShardingValueHelper(i, i);
                  Connection connection = shardingDataSource.getConnection()) {
-                PreparedStatement pstmt = connection.prepareStatement(String.format(sql, i, i));
-                pstmt.setString(1, "insert");
-                pstmt.executeUpdate();
+                PreparedStatement preparedStatement = connection.prepareStatement(String.format(sql, i, i));
+                preparedStatement.setString(1, "insert");
+                preparedStatement.executeUpdate();
             }
         }
-        assertDataset("insert", "insert");
+        assertDataSet("insert", "insert");
     }
     
     @Test
@@ -102,15 +102,15 @@ public final class DMLShardingDataBasesOnlyHintTest extends AbstractShardingData
             for (int j = 0; j < 2; j++) {
                 try (DynamicShardingValueHelper helper = new DynamicShardingValueHelper(i, i * 100 + j);
                      Connection connection = shardingDataSource.getConnection()) {
-                    PreparedStatement pstmt = connection.prepareStatement(sql);
-                    pstmt.setString(1, "updated");
-                    pstmt.setInt(2, i * 100 + j);
-                    pstmt.setInt(3, i);
-                    assertThat(pstmt.executeUpdate(), is(1));
+                    PreparedStatement preparedStatement = connection.prepareStatement(sql);
+                    preparedStatement.setString(1, "updated");
+                    preparedStatement.setInt(2, i * 100 + j);
+                    preparedStatement.setInt(3, i);
+                    assertThat(preparedStatement.executeUpdate(), is(1));
                 }
             }
         }
-        assertDataset("update", "updated");
+        assertDataSet("update", "updated");
     }
     
     @Test
@@ -120,15 +120,15 @@ public final class DMLShardingDataBasesOnlyHintTest extends AbstractShardingData
             for (int j = 0; j < 2; j++) {
                 try (DynamicShardingValueHelper helper = new DynamicShardingValueHelper(i, i * 100 + j);
                      Connection connection = shardingDataSource.getConnection()) {
-                    PreparedStatement pstmt = connection.prepareStatement(sql);
-                    pstmt.setString(1, "updated");
-                    pstmt.setInt(2, i * 100 + j);
-                    pstmt.setInt(3, i);
-                    assertThat(pstmt.executeUpdate(), is(1));
+                    PreparedStatement preparedStatement = connection.prepareStatement(sql);
+                    preparedStatement.setString(1, "updated");
+                    preparedStatement.setInt(2, i * 100 + j);
+                    preparedStatement.setInt(3, i);
+                    assertThat(preparedStatement.executeUpdate(), is(1));
                 }
             }
         }
-        assertDataset("update", "updated");
+        assertDataSet("update", "updated");
     }
     
     @Test
@@ -138,18 +138,18 @@ public final class DMLShardingDataBasesOnlyHintTest extends AbstractShardingData
             for (int j = 0; j < 2; j++) {
                 try (DynamicShardingValueHelper helper = new DynamicShardingValueHelper(i, i * 100 + j);
                      Connection connection = shardingDataSource.getConnection()) {
-                    PreparedStatement pstmt = connection.prepareStatement(sql);
-                    pstmt.setInt(1, i * 100 + j);
-                    pstmt.setInt(2, i);
-                    pstmt.setString(3, "init");
-                    assertThat(pstmt.executeUpdate(), is(1));
+                    PreparedStatement preparedStatement = connection.prepareStatement(sql);
+                    preparedStatement.setInt(1, i * 100 + j);
+                    preparedStatement.setInt(2, i);
+                    preparedStatement.setString(3, "init");
+                    assertThat(preparedStatement.executeUpdate(), is(1));
                 }
             }
         }
-        assertDataset("delete", "init");
+        assertDataSet("delete", "init");
     }
     
-    private void assertDataset(final String expectedDataSetPattern, final String status) throws SQLException, DatabaseUnitException {
+    private void assertDataSet(final String expectedDataSetPattern, final String status) throws SQLException, DatabaseUnitException {
         for (int i = 0; i < 10; i++) {
             assertDataSet(String.format("integrate/dataset/db/expect/%s/db_%s.xml", expectedDataSetPattern, i),
                     shardingDataSource.getConnection().getConnection(String.format("dataSource_db_%s", i)), "t_order", "SELECT * FROM `t_order` WHERE `status`=?", status);

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/integrate/hint/SelectShardingDataBasesOnlyHintTest.java

@@ -38,24 +38,24 @@ public final class SelectShardingDataBasesOnlyHintTest extends AbstractShardingD
     @Test
     public void assertSelectEqualsWithSingleTable() throws SQLException, DatabaseUnitException {
         String sql = "SELECT * FROM `t_order` WHERE `user_id` = ? AND `order_id` = ?";
-        assertDataset("integrate/dataset/db/expect/select/SelectEqualsWithSingleTable_0.xml", new DynamicShardingValueHelper(10, 1000), shardingDataSource.getConnection(), "t_order", sql, 10, 1000);
-        assertDataset("integrate/dataset/db/expect/select/SelectEqualsWithSingleTable_1.xml", new DynamicShardingValueHelper(12, 1201), shardingDataSource.getConnection(), "t_order", sql, 12, 1201);
-        assertDataset("integrate/dataset/Empty.xml", new DynamicShardingValueHelper(12, 1000), shardingDataSource.getConnection(), "t_order", sql, 12, 1000);
+        assertDataSet("integrate/dataset/db/expect/select/SelectEqualsWithSingleTable_0.xml", new DynamicShardingValueHelper(10, 1000), shardingDataSource.getConnection(), "t_order", sql, 10, 1000);
+        assertDataSet("integrate/dataset/db/expect/select/SelectEqualsWithSingleTable_1.xml", new DynamicShardingValueHelper(12, 1201), shardingDataSource.getConnection(), "t_order", sql, 12, 1201);
+        assertDataSet("integrate/dataset/Empty.xml", new DynamicShardingValueHelper(12, 1000), shardingDataSource.getConnection(), "t_order", sql, 12, 1000);
     }
     
     @Test
     public void assertSelectBetweenWithSingleTable() throws SQLException, DatabaseUnitException {
         String sql = "SELECT * FROM `t_order` WHERE `user_id` BETWEEN ? AND ? AND `order_id` BETWEEN ? AND ? ORDER BY user_id, order_id";
-        assertDataset("integrate/dataset/db/expect/select/SelectBetweenWithSingleTable.xml", new DynamicShardingValueHelper(Lists.newArrayList(10, 12), Condition.BinaryOperator.BETWEEN, Lists.newArrayList(1001, 1200), Condition.BinaryOperator.BETWEEN), shardingDataSource.getConnection(), "t_order", sql, 10, 12, 1001, 1200);
-        assertDataset("integrate/dataset/Empty.xml", new DynamicShardingValueHelper(Lists.newArrayList(10, 12), Condition.BinaryOperator.BETWEEN, Lists.newArrayList(1309, 1408), Condition.BinaryOperator.BETWEEN), shardingDataSource.getConnection(), "t_order", sql, 10, 12, 1309, 1408);
+        assertDataSet("integrate/dataset/db/expect/select/SelectBetweenWithSingleTable.xml", new DynamicShardingValueHelper(Lists.newArrayList(10, 12), Condition.BinaryOperator.BETWEEN, Lists.newArrayList(1001, 1200), Condition.BinaryOperator.BETWEEN), shardingDataSource.getConnection(), "t_order", sql, 10, 12, 1001, 1200);
+        assertDataSet("integrate/dataset/Empty.xml", new DynamicShardingValueHelper(Lists.newArrayList(10, 12), Condition.BinaryOperator.BETWEEN, Lists.newArrayList(1309, 1408), Condition.BinaryOperator.BETWEEN), shardingDataSource.getConnection(), "t_order", sql, 10, 12, 1309, 1408);
     }
     
     @Test
     public void assertSelectInWithSingleTable() throws SQLException, DatabaseUnitException {
         String sql = "SELECT * FROM `t_order` WHERE `user_id` IN (?, ?, ?) AND `order_id` IN (?, ?) ORDER BY user_id, order_id";
-        assertDataset("integrate/dataset/db/expect/select/SelectInWithSingleTable_0.xml", new DynamicShardingValueHelper(Lists.newArrayList(10, 12, 15), Condition.BinaryOperator.IN, Lists.newArrayList(1000, 1201), Condition.BinaryOperator.IN), shardingDataSource.getConnection(), "t_order", sql, 10, 12, 15, 1000, 1201);
-        assertDataset("integrate/dataset/db/expect/select/SelectInWithSingleTable_1.xml", new DynamicShardingValueHelper(Lists.newArrayList(10, 12, 15), Condition.BinaryOperator.IN, Lists.newArrayList(1000, 1101), Condition.BinaryOperator.IN), shardingDataSource.getConnection(), "t_order", sql, 10, 12, 15, 1000, 1101);
-        assertDataset("integrate/dataset/Empty.xml", new DynamicShardingValueHelper(Lists.newArrayList(10, 12, 15), Condition.BinaryOperator.IN, Lists.newArrayList(1309, 1408), Condition.BinaryOperator.IN), shardingDataSource.getConnection(), "t_order", sql, 10, 12, 15, 1309, 1408);
+        assertDataSet("integrate/dataset/db/expect/select/SelectInWithSingleTable_0.xml", new DynamicShardingValueHelper(Lists.newArrayList(10, 12, 15), Condition.BinaryOperator.IN, Lists.newArrayList(1000, 1201), Condition.BinaryOperator.IN), shardingDataSource.getConnection(), "t_order", sql, 10, 12, 15, 1000, 1201);
+        assertDataSet("integrate/dataset/db/expect/select/SelectInWithSingleTable_1.xml", new DynamicShardingValueHelper(Lists.newArrayList(10, 12, 15), Condition.BinaryOperator.IN, Lists.newArrayList(1000, 1101), Condition.BinaryOperator.IN), shardingDataSource.getConnection(), "t_order", sql, 10, 12, 15, 1000, 1101);
+        assertDataSet("integrate/dataset/Empty.xml", new DynamicShardingValueHelper(Lists.newArrayList(10, 12, 15), Condition.BinaryOperator.IN, Lists.newArrayList(1309, 1408), Condition.BinaryOperator.IN), shardingDataSource.getConnection(), "t_order", sql, 10, 12, 15, 1309, 1408);
     }
     
 }

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/integrate/nullable/AbstractShardingNullableDBUnitTest.java

@@ -35,7 +35,7 @@ import com.dangdang.ddframe.rdb.sharding.api.strategy.table.TableShardingStrateg
 
 public abstract class AbstractShardingNullableDBUnitTest extends AbstractDBUnitTest {
     
-    private String dataSourceName = "dataSource_%s";
+    private final String dataSourceName = "dataSource_%s";
     
     @Override
     protected List<String> getSchemaFiles() {
@@ -67,7 +67,7 @@ public abstract class AbstractShardingNullableDBUnitTest extends AbstractDBUnitT
                 "integrate/dataset/nullable/init/nullable_9.xml");
     }
     
-    protected final ShardingDataSource getShardingDataSource() throws SQLException {
+    protected final ShardingDataSource getShardingDataSource() {
         DataSourceRule dataSourceRule = new DataSourceRule(createDataSourceMap(dataSourceName));
         TableRule orderTableRule = new TableRule("t_order", Collections.singletonList("t_order"), dataSourceRule);
         ShardingRule shardingRule = new ShardingRule(dataSourceRule, Collections.singletonList(orderTableRule), Collections.singletonList(new BindingTableRule(Collections.singletonList(orderTableRule))),

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/integrate/tbl/AbstractShardingTablesOnlyDBUnitTest.java

@@ -35,7 +35,7 @@ import com.dangdang.ddframe.rdb.sharding.api.strategy.table.TableShardingStrateg
 
 public abstract class AbstractShardingTablesOnlyDBUnitTest extends AbstractDBUnitTest {
     
-    private String dataSourceName = "dataSource_%s";
+    private final String dataSourceName = "dataSource_%s";
     
     @Override
     protected List<String> getSchemaFiles() {
@@ -47,7 +47,7 @@ public abstract class AbstractShardingTablesOnlyDBUnitTest extends AbstractDBUni
         return Collections.singletonList("integrate/dataset/tbl/init/db_single.xml");
     }
     
-    protected final ShardingDataSource getShardingDataSource() throws SQLException {
+    protected final ShardingDataSource getShardingDataSource() {
         DataSourceRule dataSourceRule = new DataSourceRule(createDataSourceMap(dataSourceName));
         TableRule orderTableRule = new TableRule("t_order", Arrays.asList(
                 "t_order_0", 

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/integrate/tbl/DMLShardingTablesOnlyTest.java

@@ -44,67 +44,67 @@ public final class DMLShardingTablesOnlyTest extends AbstractShardingTablesOnlyD
         String sql = "INSERT INTO `t_order` (`order_id`, `user_id`, `status`) VALUES (?, ?, ?)";
         for (int i = 1; i <= 10; i++) {
             try (Connection connection = shardingDataSource.getConnection()) {
-                PreparedStatement pstmt = connection.prepareStatement(sql);
-                pstmt.setInt(1, i);
-                pstmt.setInt(2, i);
-                pstmt.setString(3, "insert");
-                pstmt.executeUpdate();
+                PreparedStatement preparedStatement = connection.prepareStatement(sql);
+                preparedStatement.setInt(1, i);
+                preparedStatement.setInt(2, i);
+                preparedStatement.setString(3, "insert");
+                preparedStatement.executeUpdate();
             }
         }
-        assertDataset("insert", "insert");
+        assertDataSet("insert", "insert");
     }
     
     @Test
-    public void assertInsertWithAllPlacehloders() throws SQLException, DatabaseUnitException {
+    public void assertInsertWithAllPlaceholders() throws SQLException, DatabaseUnitException {
         String sql = "INSERT INTO `t_order` (`order_id`, `user_id`, `status`) VALUES (?, ?, ?)";
         for (int i = 1; i <= 10; i++) {
             try (Connection connection = shardingDataSource.getConnection()) {
-                PreparedStatement pstmt = connection.prepareStatement(sql);
-                pstmt.setInt(1, i);
-                pstmt.setInt(2, i);
-                pstmt.setString(3, "insert");
-                pstmt.executeUpdate();
+                PreparedStatement preparedStatement = connection.prepareStatement(sql);
+                preparedStatement.setInt(1, i);
+                preparedStatement.setInt(2, i);
+                preparedStatement.setString(3, "insert");
+                preparedStatement.executeUpdate();
             }
         }
-        assertDataset("insert", "insert");
+        assertDataSet("insert", "insert");
     }
     
     @Test
-    public void assertInsertWithoutPlacehloder() throws SQLException, DatabaseUnitException {
+    public void assertInsertWithoutPlaceholder() throws SQLException, DatabaseUnitException {
         String sql = "INSERT INTO `t_order` (`order_id`, `user_id`, `status`) VALUES (%s, %s, 'insert')";
         for (int i = 1; i <= 10; i++) {
             try (Connection connection = shardingDataSource.getConnection()) {
-                PreparedStatement pstmt = connection.prepareStatement(String.format(sql, i, i));
-                pstmt.executeUpdate();
+                PreparedStatement preparedStatement = connection.prepareStatement(String.format(sql, i, i));
+                preparedStatement.executeUpdate();
             }
         }
-        assertDataset("insert", "insert");
+        assertDataSet("insert", "insert");
     }
     
     @Test
-    public void assertInsertWithPlacehlodersForShardingKeys() throws SQLException, DatabaseUnitException {
+    public void assertInsertWithPlaceholdersForShardingKeys() throws SQLException, DatabaseUnitException {
         String sql = "INSERT INTO `t_order` (`order_id`, `user_id`, `status`) VALUES (%s, %s, ?)";
         for (int i = 1; i <= 10; i++) {
             try (Connection connection = shardingDataSource.getConnection()) {
-                PreparedStatement pstmt = connection.prepareStatement(String.format(sql, i, i));
-                pstmt.setString(1, "insert");
-                pstmt.executeUpdate();
+                PreparedStatement preparedStatement = connection.prepareStatement(String.format(sql, i, i));
+                preparedStatement.setString(1, "insert");
+                preparedStatement.executeUpdate();
             }
         }
-        assertDataset("insert", "insert");
+        assertDataSet("insert", "insert");
     }
     
     @Test
-    public void assertInsertWithPlacehlodersForNotShardingKeys() throws SQLException, DatabaseUnitException {
+    public void assertInsertWithPlaceholdersForNotShardingKeys() throws SQLException, DatabaseUnitException {
         String sql = "INSERT INTO `t_order` (`order_id`, `user_id`, `status`) VALUES (%s, %s, ?)";
         for (int i = 1; i <= 10; i++) {
             try (Connection connection = shardingDataSource.getConnection()) {
-                PreparedStatement pstmt = connection.prepareStatement(String.format(sql, i, i));
-                pstmt.setString(1, "insert");
-                pstmt.executeUpdate();
+                PreparedStatement preparedStatement = connection.prepareStatement(String.format(sql, i, i));
+                preparedStatement.setString(1, "insert");
+                preparedStatement.executeUpdate();
             }
         }
-        assertDataset("insert", "insert");
+        assertDataSet("insert", "insert");
     }
     
     @Test
@@ -114,15 +114,15 @@ public final class DMLShardingTablesOnlyTest extends AbstractShardingTablesOnlyD
         for (int i = 10; i < 12; i++) {
             for (int j = 0; j < 10; j++) {
                 try (Connection connection = shardingDataSource.getConnection()) {
-                    PreparedStatement pstmt = connection.prepareStatement(sql);
-                    pstmt.setString(1, "updated");
-                    pstmt.setInt(2, i * 100 + j);
-                    pstmt.setInt(3, i);
-                    assertThat(pstmt.executeUpdate(), is(1));
+                    PreparedStatement preparedStatement = connection.prepareStatement(sql);
+                    preparedStatement.setString(1, "updated");
+                    preparedStatement.setInt(2, i * 100 + j);
+                    preparedStatement.setInt(3, i);
+                    assertThat(preparedStatement.executeUpdate(), is(1));
                 }
             }
         }
-        assertDataset("update", "updated");
+        assertDataSet("update", "updated");
     }
     
     @Test
@@ -132,15 +132,15 @@ public final class DMLShardingTablesOnlyTest extends AbstractShardingTablesOnlyD
         for (int i = 10; i < 12; i++) {
             for (int j = 0; j < 10; j++) {
                 try (Connection connection = shardingDataSource.getConnection()) {
-                    PreparedStatement pstmt = connection.prepareStatement(sql);
-                    pstmt.setString(1, "updated");
-                    pstmt.setInt(2, i * 100 + j);
-                    pstmt.setInt(3, i);
-                    assertThat(pstmt.executeUpdate(), is(1));
+                    PreparedStatement preparedStatement = connection.prepareStatement(sql);
+                    preparedStatement.setString(1, "updated");
+                    preparedStatement.setInt(2, i * 100 + j);
+                    preparedStatement.setInt(3, i);
+                    assertThat(preparedStatement.executeUpdate(), is(1));
                 }
             }
         }
-        assertDataset("update", "updated");
+        assertDataSet("update", "updated");
     }
     
     @Test
@@ -148,12 +148,12 @@ public final class DMLShardingTablesOnlyTest extends AbstractShardingTablesOnlyD
         ShardingDataSource shardingDataSource = getShardingDataSource();
         String sql = "UPDATE `t_order` SET `status` = ? WHERE `status` = ?";
         try (Connection connection = shardingDataSource.getConnection()) {
-            PreparedStatement pstmt = connection.prepareStatement(sql);
-            pstmt.setString(1, "updated");
-            pstmt.setString(2, "init");
-            assertThat(pstmt.executeUpdate(), is(20));
+            PreparedStatement preparedStatement = connection.prepareStatement(sql);
+            preparedStatement.setString(1, "updated");
+            preparedStatement.setString(2, "init");
+            assertThat(preparedStatement.executeUpdate(), is(20));
         }
-        assertDataset("update", "updated");
+        assertDataSet("update", "updated");
     }
     
     @Test
@@ -163,15 +163,15 @@ public final class DMLShardingTablesOnlyTest extends AbstractShardingTablesOnlyD
         for (int i = 10; i < 12; i++) {
             for (int j = 0; j < 10; j++) {
                 try (Connection connection = shardingDataSource.getConnection()) {
-                    PreparedStatement pstmt = connection.prepareStatement(sql);
-                    pstmt.setInt(1, i * 100 + j);
-                    pstmt.setInt(2, i);
-                    pstmt.setString(3, "init");
-                    assertThat(pstmt.executeUpdate(), is(1));
+                    PreparedStatement preparedStatement = connection.prepareStatement(sql);
+                    preparedStatement.setInt(1, i * 100 + j);
+                    preparedStatement.setInt(2, i);
+                    preparedStatement.setString(3, "init");
+                    assertThat(preparedStatement.executeUpdate(), is(1));
                 }
             }   
         }
-        assertDataset("delete", "init");
+        assertDataSet("delete", "init");
     }
     
     @Test
@@ -179,14 +179,14 @@ public final class DMLShardingTablesOnlyTest extends AbstractShardingTablesOnlyD
         ShardingDataSource shardingDataSource = getShardingDataSource();
         String sql = "DELETE `t_order` WHERE `status` = ?";
         try (Connection connection = shardingDataSource.getConnection()) {
-            PreparedStatement pstmt = connection.prepareStatement(sql);
-            pstmt.setString(1, "init");
-            assertThat(pstmt.executeUpdate(), is(20));
+            PreparedStatement preparedStatement = connection.prepareStatement(sql);
+            preparedStatement.setString(1, "init");
+            assertThat(preparedStatement.executeUpdate(), is(20));
         }
-        assertDataset("delete", "init");
+        assertDataSet("delete", "init");
     }
     
-    private void assertDataset(final String expectedDataSetPattern, final String status) throws SQLException, DatabaseUnitException {
+    private void assertDataSet(final String expectedDataSetPattern, final String status) throws SQLException, DatabaseUnitException {
         for (int i = 0; i < 10; i++) {
             assertDataSet(String.format("integrate/dataset/tbl/expect/%s/db_single.xml", expectedDataSetPattern), 
                     shardingDataSource.getConnection().getConnection("dataSource_db_single"), 

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/integrate/tbl/SelectShardingTablesOnlyTest.java

@@ -91,10 +91,10 @@ public final class SelectShardingTablesOnlyTest extends AbstractShardingTablesOn
     }
     
     @Test
-    public void assertSelectWithBingdingTableAndConfigTable() throws SQLException, DatabaseUnitException {
+    public void assertSelectWithBindingTableAndConfigTable() throws SQLException, DatabaseUnitException {
         String sql = "SELECT i.* FROM `t_order` o JOIN `t_order_item` i ON o.user_id = i.user_id AND o.order_id = i.order_id JOIN `t_config` c ON o.status = c.status"
                 + " WHERE o.`user_id` IN (?, ?) AND o.`order_id` BETWEEN ? AND ? AND c.status = ? ORDER BY i.item_id";
-        assertDataSet("integrate/dataset/tbl/expect/select/SelectWithBingdingTableAndConfigTable.xml", shardingDataSource.getConnection(), "t_order_item", sql, 10, 11, 1009, 1108, "init");
+        assertDataSet("integrate/dataset/tbl/expect/select/SelectWithBindingTableAndConfigTable.xml", shardingDataSource.getConnection(), "t_order_item", sql, 10, 11, 1009, 1108, "init");
         assertDataSet("integrate/dataset/Empty.xml", shardingDataSource.getConnection(), "t_order_item", sql, 10, 11, 1009, 1108, "none");
     }
     

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/integrate/tbl/StatementDMLShardingTablesOnlyTest.java

@@ -47,7 +47,7 @@ public final class StatementDMLShardingTablesOnlyTest extends AbstractShardingTa
                 stmt.executeUpdate(String.format(sql, i, i, "insert"));
             }
         }
-        assertDataset("insert", "insert");
+        assertDataSet("insert", "insert");
     }
     
     @Test
@@ -62,7 +62,7 @@ public final class StatementDMLShardingTablesOnlyTest extends AbstractShardingTa
                 }
             }
         }
-        assertDataset("update", "updated");
+        assertDataSet("update", "updated");
     }
     
     @Test
@@ -73,7 +73,7 @@ public final class StatementDMLShardingTablesOnlyTest extends AbstractShardingTa
             Statement stmt = connection.createStatement();
             assertThat(stmt.executeUpdate(String.format(sql, "updated", "init")), is(20));
         }
-        assertDataset("update", "updated");
+        assertDataSet("update", "updated");
     }
     
     
@@ -89,7 +89,7 @@ public final class StatementDMLShardingTablesOnlyTest extends AbstractShardingTa
                 }
             }   
         }
-        assertDataset("delete", "init");
+        assertDataSet("delete", "init");
     }
     
     @Test
@@ -100,10 +100,10 @@ public final class StatementDMLShardingTablesOnlyTest extends AbstractShardingTa
             Statement stmt = connection.createStatement();
             assertThat(stmt.executeUpdate(String.format(sql, "init")), is(20));
         }
-        assertDataset("delete", "init");
+        assertDataSet("delete", "init");
     }
     
-    private void assertDataset(final String expectedDataSetPattern, final String status) throws SQLException, DatabaseUnitException {
+    private void assertDataSet(final String expectedDataSetPattern, final String status) throws SQLException, DatabaseUnitException {
         for (int i = 0; i < 10; i++) {
             assertDataSet(String.format("integrate/dataset/tbl/expect/%s/db_single.xml", expectedDataSetPattern),
                     shardingDataSource.getConnection().getConnection("dataSource_db_single"), 

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/integrate/tbl/StatementSelectShardingTablesOnlyTest.java

@@ -82,10 +82,10 @@ public final class StatementSelectShardingTablesOnlyTest extends AbstractShardin
     }
     
     @Test
-    public void assertSelectWithBingdingTableAndConfigTable() throws SQLException, DatabaseUnitException {
+    public void assertSelectWithBindingTableAndConfigTable() throws SQLException, DatabaseUnitException {
         String sql = "SELECT i.* FROM `t_order` o JOIN `t_order_item` i ON o.user_id = i.user_id AND o.order_id = i.order_id JOIN `t_config` c ON o.status = c.status"
                 + " WHERE o.`user_id` IN (%s, %s) AND o.`order_id` BETWEEN %s AND %s AND c.status = '%s' ORDER BY i.item_id";
-        assertDataSet("integrate/dataset/tbl/expect/select/SelectWithBingdingTableAndConfigTable.xml", 
+        assertDataSet("integrate/dataset/tbl/expect/select/SelectWithBindingTableAndConfigTable.xml", 
                 shardingDataSource.getConnection(), "t_order_item", String.format(sql, 10, 11, 1009, 1108, "init"));
         assertDataSet("integrate/dataset/Empty.xml", shardingDataSource.getConnection(), "t_order_item", String.format(sql, 10, 11, 1009, 1108, "none"));
     }

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/api/HintShardingValueManagerTest.java

@@ -88,11 +88,11 @@ public class HintShardingValueManagerTest {
     public void testMultiValues() {
         HintShardingValueManager.registerShardingValueOfTable("test", "test1", 1);
         HintShardingValueManager.registerShardingValueOfTable("test", "test2", 2);
-        Iterator<ShardingValue<?>> iter = HintShardingValueManager.getShardingValueOfTable("test").get().iterator();
-        ShardingValue<?> shardingValue = iter.next();
+        Iterator<ShardingValue<?>> iterator = HintShardingValueManager.getShardingValueOfTable("test").get().iterator();
+        ShardingValue<?> shardingValue = iterator.next();
         assertThat(shardingValue.getColumnName(), is("test1"));
         assertThat((Integer) shardingValue.getValue(), is(1));
-        shardingValue = iter.next();
+        shardingValue = iterator.next();
         assertThat(shardingValue.getColumnName(), is("test2"));
         assertThat((Integer) shardingValue.getValue(), is(2));
     }

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/api/rule/DataSourceRuleTest.java

@@ -18,7 +18,7 @@ import com.google.common.collect.Sets;
 
 public final class DataSourceRuleTest {
     
-    private Map<String, DataSource> dataSourceMap = new HashMap<>(3);
+    private final Map<String, DataSource> dataSourceMap = new HashMap<>(3);
     
     private DataSourceRule dataSourceRule;
     
@@ -58,6 +58,6 @@ public final class DataSourceRuleTest {
     
     @Test
     public void assertGetDataSources() {
-        assertThat(dataSourceRule.getDataSources(), is((Collection<DataSource>) dataSourceMap.values()));
+        assertThat(dataSourceRule.getDataSources(), is(dataSourceMap.values()));
     }
 }

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/api/strategy/database/NoneDatabaseShardingAlgorithmTest.java

@@ -39,7 +39,7 @@ public final class NoneDatabaseShardingAlgorithmTest {
     }
     
     @Test
-    public void assertDoEqualShardingForTargetsEmtpy() {
+    public void assertDoEqualShardingForTargetsEmpty() {
         assertNull(noneDatabaseShardingAlgorithm.doEqualSharding(Collections.<String>emptyList(), null));
     }
     

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/api/strategy/table/NoneTableShardingAlgorithmTest.java

@@ -34,7 +34,7 @@ public final class NoneTableShardingAlgorithmTest {
     private final Collection<String> targets = Collections.singletonList("tbl");
     
     @Test
-    public void assertDoEqualShardingForTargetsEmtpy() {
+    public void assertDoEqualShardingForTargetsEmpty() {
         assertNull(noneTableShardingAlgorithm.doEqualSharding(Collections.<String>emptyList(), null));
     }
     

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/jdbc/ShardingPreparedStatementTest.java

@@ -48,9 +48,9 @@ public final class ShardingPreparedStatementTest extends AbstractShardingDataBas
         String sql = "SELECT COUNT(*) AS `orders_count` FROM `t_order` WHERE `status` = ?";
         try (
                 Connection connection = shardingDataSource.getConnection();
-                PreparedStatement pstmt = connection.prepareStatement(sql)) {
-            pstmt.setString(1, "init");
-            ResultSet resultSet = pstmt.executeQuery();
+                PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
+            preparedStatement.setString(1, "init");
+            ResultSet resultSet = preparedStatement.executeQuery();
             assertTrue(resultSet.next());
             assertThat(resultSet.getLong(1), is(40L));
         }
@@ -61,8 +61,8 @@ public final class ShardingPreparedStatementTest extends AbstractShardingDataBas
         String sql = "SELECT COUNT(*) AS `orders_count` FROM `t_order` WHERE `status` = 'init'";
         try (
                 Connection connection = shardingDataSource.getConnection();
-                PreparedStatement pstmt = connection.prepareStatement(sql)) {
-            ResultSet resultSet = pstmt.executeQuery();
+                PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
+            ResultSet resultSet = preparedStatement.executeQuery();
             assertTrue(resultSet.next());
             assertThat(resultSet.getLong(1), is(40L));
         }
@@ -73,9 +73,9 @@ public final class ShardingPreparedStatementTest extends AbstractShardingDataBas
         String sql = "DELETE FROM `t_order` WHERE `status` = ?";
         try (
                 Connection connection = shardingDataSource.getConnection();
-                PreparedStatement pstmt = connection.prepareStatement(sql)) {
-            pstmt.setString(1, "init");
-            assertThat(pstmt.executeUpdate(), is(40));
+                PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
+            preparedStatement.setString(1, "init");
+            assertThat(preparedStatement.executeUpdate(), is(40));
         }
     }
     
@@ -84,8 +84,8 @@ public final class ShardingPreparedStatementTest extends AbstractShardingDataBas
         String sql = "DELETE FROM `t_order` WHERE `status` = 'init'";
         try (
                 Connection connection = shardingDataSource.getConnection();
-                PreparedStatement pstmt = connection.prepareStatement(sql)) {
-            assertThat(pstmt.executeUpdate(), is(40));
+                PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
+            assertThat(preparedStatement.executeUpdate(), is(40));
         }
     }
     
@@ -94,11 +94,11 @@ public final class ShardingPreparedStatementTest extends AbstractShardingDataBas
         String sql = "SELECT COUNT(*) AS `orders_count` FROM `t_order` WHERE `status` = ?";
         try (
                 Connection connection = shardingDataSource.getConnection();
-                PreparedStatement pstmt = connection.prepareStatement(sql)) {
-            pstmt.setString(1, "init");
-            assertTrue(pstmt.execute());
-            assertTrue(pstmt.getResultSet().next());
-            assertThat(pstmt.getResultSet().getLong(1), is(40L));
+                PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
+            preparedStatement.setString(1, "init");
+            assertTrue(preparedStatement.execute());
+            assertTrue(preparedStatement.getResultSet().next());
+            assertThat(preparedStatement.getResultSet().getLong(1), is(40L));
         }
     }
     
@@ -107,32 +107,32 @@ public final class ShardingPreparedStatementTest extends AbstractShardingDataBas
         String sql = "DELETE FROM `t_order` WHERE `status` = 'init'";
         try (
                 Connection connection = shardingDataSource.getConnection();
-                PreparedStatement pstmt = connection.prepareStatement(sql)) {
-            assertFalse(pstmt.execute());
+                PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
+            assertFalse(preparedStatement.execute());
         }
     }
     
     @Test
-    public void assertExecuteQueryWithResultSetTypeAndRsultSetConcurrency() throws SQLException {
+    public void assertExecuteQueryWithResultSetTypeAndResultSetConcurrency() throws SQLException {
         String sql = "SELECT COUNT(*) AS `orders_count` FROM `t_order` WHERE `status` = ?";
         try (
                 Connection connection = shardingDataSource.getConnection();
-                PreparedStatement pstmt = connection.prepareStatement(sql, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY)) {
-            pstmt.setString(1, "init");
-            ResultSet resultSet = pstmt.executeQuery();
+                PreparedStatement preparedStatement = connection.prepareStatement(sql, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY)) {
+            preparedStatement.setString(1, "init");
+            ResultSet resultSet = preparedStatement.executeQuery();
             assertTrue(resultSet.next());
             assertThat(resultSet.getLong(1), is(40L));
         }
     }
     
     @Test
-    public void assertExecuteQueryWithResultSetTypeAndRsultSetConcurrencyAndResultSetHoldability() throws SQLException {
+    public void assertExecuteQueryWithResultSetTypeAndResultSetConcurrencyAndResultSetHoldability() throws SQLException {
         String sql = "SELECT COUNT(*) AS `orders_count` FROM `t_order` WHERE `status` = ?";
         try (
                 Connection connection = shardingDataSource.getConnection();
-                PreparedStatement pstmt = connection.prepareStatement(sql, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, ResultSet.HOLD_CURSORS_OVER_COMMIT)) {
-            pstmt.setString(1, "init");
-            ResultSet resultSet = pstmt.executeQuery();
+                PreparedStatement preparedStatement = connection.prepareStatement(sql, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, ResultSet.HOLD_CURSORS_OVER_COMMIT)) {
+            preparedStatement.setString(1, "init");
+            ResultSet resultSet = preparedStatement.executeQuery();
             assertTrue(resultSet.next());
             assertThat(resultSet.getLong(1), is(40L));
         }
@@ -143,9 +143,9 @@ public final class ShardingPreparedStatementTest extends AbstractShardingDataBas
         String sql = "SELECT COUNT(*) AS `orders_count` FROM `t_order` WHERE `status` = ?";
         try (
                 Connection connection = shardingDataSource.getConnection();
-                PreparedStatement pstmt = connection.prepareStatement(sql, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, 0)) {
-            pstmt.setString(1, "init");
-            ResultSet resultSet = pstmt.executeQuery();
+                PreparedStatement preparedStatement = connection.prepareStatement(sql, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, 0)) {
+            preparedStatement.setString(1, "init");
+            ResultSet resultSet = preparedStatement.executeQuery();
             assertTrue(resultSet.next());
             assertThat(resultSet.getLong(1), is(40L));
         }
@@ -156,9 +156,9 @@ public final class ShardingPreparedStatementTest extends AbstractShardingDataBas
         String sql = "SELECT COUNT(*) AS `orders_count` FROM `t_order` WHERE `status` = ?";
         try (
                 Connection connection = shardingDataSource.getConnection();
-                PreparedStatement pstmt = connection.prepareStatement(sql, Statement.NO_GENERATED_KEYS)) {
-            pstmt.setString(1, "init");
-            ResultSet resultSet = pstmt.executeQuery();
+                PreparedStatement preparedStatement = connection.prepareStatement(sql, Statement.NO_GENERATED_KEYS)) {
+            preparedStatement.setString(1, "init");
+            ResultSet resultSet = preparedStatement.executeQuery();
             assertTrue(resultSet.next());
             assertThat(resultSet.getLong(1), is(40L));
         }
@@ -169,9 +169,9 @@ public final class ShardingPreparedStatementTest extends AbstractShardingDataBas
         String sql = "SELECT COUNT(*) AS `orders_count` FROM `t_order` WHERE `status` = ?";
         try (
                 Connection connection = shardingDataSource.getConnection();
-                PreparedStatement pstmt = connection.prepareStatement(sql, new int[] {1})) {
-            pstmt.setNull(1, java.sql.Types.VARCHAR);
-            ResultSet resultSet = pstmt.executeQuery();
+                PreparedStatement preparedStatement = connection.prepareStatement(sql, new int[] {1})) {
+            preparedStatement.setNull(1, java.sql.Types.VARCHAR);
+            ResultSet resultSet = preparedStatement.executeQuery();
             assertTrue(resultSet.next());
             assertThat(resultSet.getLong(1), is(0L));
         }
@@ -182,9 +182,9 @@ public final class ShardingPreparedStatementTest extends AbstractShardingDataBas
         String sql = "SELECT COUNT(*) AS `orders_count` FROM `t_order` WHERE `status` = ?";
         try (
                 Connection connection = shardingDataSource.getConnection();
-                PreparedStatement pstmt = connection.prepareStatement(sql, new String[] {"orders_count"})) {
-            pstmt.setNull(1, java.sql.Types.VARCHAR);
-            ResultSet resultSet = pstmt.executeQuery();
+                PreparedStatement preparedStatement = connection.prepareStatement(sql, new String[] {"orders_count"})) {
+            preparedStatement.setNull(1, java.sql.Types.VARCHAR);
+            ResultSet resultSet = preparedStatement.executeQuery();
             assertTrue(resultSet.next());
             assertThat(resultSet.getLong(1), is(0L));
         }
@@ -195,16 +195,16 @@ public final class ShardingPreparedStatementTest extends AbstractShardingDataBas
         String sql = "INSERT INTO `t_order`(`order_id`, `user_id`, `status`) VALUES (?,?,?)";
         try (
                 Connection connection = shardingDataSource.getConnection();
-                PreparedStatement pstmt = connection.prepareStatement(sql)) {
-            pstmt.setInt(1, 3101);
-            pstmt.setInt(2, 11);
-            pstmt.setString(3, "BATCH");
-            pstmt.addBatch();
-            pstmt.setInt(1, 3102);
-            pstmt.setInt(2, 12);
-            pstmt.setString(3, "BATCH");
-            pstmt.addBatch();
-            int[] result = pstmt.executeBatch();
+                PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
+            preparedStatement.setInt(1, 3101);
+            preparedStatement.setInt(2, 11);
+            preparedStatement.setString(3, "BATCH");
+            preparedStatement.addBatch();
+            preparedStatement.setInt(1, 3102);
+            preparedStatement.setInt(2, 12);
+            preparedStatement.setString(3, "BATCH");
+            preparedStatement.addBatch();
+            int[] result = preparedStatement.executeBatch();
             for (int each : result) {
                 assertThat(each, is(1));
             }

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/jdbc/ShardingStatementTest.java

@@ -76,7 +76,7 @@ public final class ShardingStatementTest extends AbstractShardingDataBasesOnlyDB
     }
     
     @Test
-    public void assertExecuteQueryWithResultSetTypeAndRsultSetConcurrency() throws SQLException {
+    public void assertExecuteQueryWithResultSetTypeAndResultSetConcurrency() throws SQLException {
         String sql = "SELECT COUNT(*) AS `orders_count` FROM `t_order` WHERE `status` = 'init'";
         try (
                 Connection connection = shardingDataSource.getConnection();
@@ -88,7 +88,7 @@ public final class ShardingStatementTest extends AbstractShardingDataBasesOnlyDB
     }
     
     @Test
-    public void assertExecuteQueryWithResultSetTypeAndRsultSetConcurrencyAndResultSetHoldability() throws SQLException {
+    public void assertExecuteQueryWithResultSetTypeAndResultSetConcurrencyAndResultSetHoldability() throws SQLException {
         String sql = "SELECT COUNT(*) AS `orders_count` FROM `t_order` WHERE `status` = 'init'";
         try (
                 Connection connection = shardingDataSource.getConnection();

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/jdbc/adapter/DataSourceAdapterTest.java

@@ -54,7 +54,7 @@ public final class DataSourceAdapterTest extends AbstractShardingDataBasesOnlyDB
     }
     
     @Test(expected = SQLException.class)
-    public void assertUnwrapFaliure() throws SQLException {
+    public void assertUnwrapFailure() throws SQLException {
         shardingDataSource.unwrap(String.class);
     }
     
@@ -73,12 +73,12 @@ public final class DataSourceAdapterTest extends AbstractShardingDataBasesOnlyDB
         List<?> list = mock(List.class);
         when(list.isEmpty()).thenReturn(true);
         shardingDataSource.recordMethodInvocation(List.class, "isEmpty", new Class[] {}, new Object[] {});
-        shardingDataSource.replayMethodsInvovation(list);
+        shardingDataSource.replayMethodsInvocation(list);
         verify(list).isEmpty();
     }
     
     @Test(expected = ShardingJdbcException.class)
-    public void assertRecordMethodInvocationFaliure() throws SQLException {
+    public void assertRecordMethodInvocationFailure() throws SQLException {
         shardingDataSource.recordMethodInvocation(String.class, "none", new Class[] {}, new Object[] {});
     }
     

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/jdbc/adapter/PreparedStatementAdapterTest.java

@@ -237,7 +237,7 @@ public final class PreparedStatementAdapterTest extends AbstractShardingDataBase
     }
     
     @Test
-    public void assertSetSQLxml() throws SQLException {
+    public void assertSetSQLXML() throws SQLException {
         actual.setSQLXML(1, null);
         assertParameter(actual, 1, null);
     }

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/jdbc/adapter/ResultSetAdapterTest.java

@@ -65,7 +65,7 @@ public final class ResultSetAdapterTest extends AbstractShardingDataBasesOnlyDBU
     }
     
     @Test
-    public void assertColse() throws SQLException {
+    public void assertClose() throws SQLException {
         actual.close();
         assertClose((AbstractShardingResultSet) actual);
     }

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/jdbc/adapter/ResultSetGetterAdapterTest.java

@@ -369,7 +369,7 @@ public final class ResultSetGetterAdapterTest extends AbstractShardingDataBasesO
     }
     
     @Test
-    public void assertGetSQLxmlForColumnIndex() throws SQLException {
+    public void assertGetSQLXMLForColumnIndex() throws SQLException {
         if (DatabaseType.H2 == AbstractDBUnitTest.CURRENT_DB_TYPE) {
             try {
                 actual.getSQLXML(1);
@@ -381,7 +381,7 @@ public final class ResultSetGetterAdapterTest extends AbstractShardingDataBasesO
     }
     
     @Test
-    public void assertGetSQLxmlForColumnLabel() throws SQLException {
+    public void assertGetSQLXMLForColumnLabel() throws SQLException {
         if (DatabaseType.H2 == AbstractDBUnitTest.CURRENT_DB_TYPE) {
             try {
                 actual.getSQLXML("uid");

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/jdbc/adapter/StatementAdapterTest.java

@@ -59,7 +59,7 @@ public final class StatementAdapterTest extends AbstractShardingDataBasesOnlyDBU
     }
     
     @Test
-    public void assertColse() throws SQLException {
+    public void assertClose() throws SQLException {
         actual.executeQuery("SELECT user_id AS `uid` FROM `t_order` WHERE `status` = 'init'");
         actual.close();
         assertTrue(actual.isClosed());

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/jdbc/unsupported/ResultSetUpdaterAdapterTest.java

@@ -448,31 +448,31 @@ public final class ResultSetUpdaterAdapterTest extends AbstractShardingDataBases
     
     @Test(expected = SQLFeatureNotSupportedException.class)
     public void assertUpdateArrayForColumnIndex() throws SQLException {
-        actual.updateArray(1, (Array) null);
+        actual.updateArray(1, null);
     }
     
     @Test(expected = SQLFeatureNotSupportedException.class)
     public void assertUpdateArrayForColumnLabel() throws SQLException {
-        actual.updateArray("label", (Array) null);
+        actual.updateArray("label", null);
     }
     
     @Test(expected = SQLFeatureNotSupportedException.class)
     public void assertUpdateRowIdForColumnIndex() throws SQLException {
-        actual.updateRowId(1, (RowId) null);
+        actual.updateRowId(1, null);
     }
     
     @Test(expected = SQLFeatureNotSupportedException.class)
     public void assertUpdateRowIdForColumnLabel() throws SQLException {
-        actual.updateRowId("label", (RowId) null);
+        actual.updateRowId("label", null);
     }
     
     @Test(expected = SQLFeatureNotSupportedException.class)
-    public void assertUpdateSQLxmlForColumnIndex() throws SQLException {
-        actual.updateSQLXML(1, (SQLXML) null);
+    public void assertUpdateSQLXMLForColumnIndex() throws SQLException {
+        actual.updateSQLXML(1, null);
     }
     
     @Test(expected = SQLFeatureNotSupportedException.class)
-    public void assertUpdateSQLxmlForColumnLabel() throws SQLException {
-        actual.updateSQLXML("label", (SQLXML) null);
+    public void assertUpdateSQXMLForColumnLabel() throws SQLException {
+        actual.updateSQLXML("label", null);
     }
 }

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/jdbc/unsupported/UnsupportedOperationConnectionTest.java

@@ -148,7 +148,7 @@ public final class UnsupportedOperationConnectionTest extends AbstractShardingDa
     }
     
     @Test(expected = SQLFeatureNotSupportedException.class)
-    public void assertCreateSQLxml() throws SQLException {
+    public void assertCreateSQLXML() throws SQLException {
         actual.createSQLXML();
     }
     

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/jdbc/unsupported/UnsupportedOperationResultSetTest.java

@@ -71,7 +71,7 @@ public final class UnsupportedOperationResultSetTest extends AbstractShardingDat
     }
     
     @Test(expected = SQLFeatureNotSupportedException.class)
-    public void assertisFirst() throws SQLException {
+    public void assertIsFirst() throws SQLException {
         actual.isFirst();
     }
     
@@ -156,7 +156,7 @@ public final class UnsupportedOperationResultSetTest extends AbstractShardingDat
     }
     
     @Test(expected = SQLFeatureNotSupportedException.class)
-    public void assertrowUpdateed() throws SQLException {
+    public void assertRowUpdated() throws SQLException {
         actual.rowUpdated();
     }
     

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/merger/ResultSetUtilTest.java

@@ -127,12 +127,12 @@ public final class ResultSetUtilTest {
     }
     
     @Test
-    public void assertcompareToForAsc() {
+    public void assertCompareToForAsc() {
         assertTrue(ResultSetUtil.compareTo(1, 2, OrderByType.ASC) < 0);
     }
     
     @Test
-    public void assertcompareToForDesc() {
+    public void assertCompareToForDesc() {
         assertFalse(ResultSetUtil.compareTo(1, 2, OrderByType.DESC) < 0);
     }
 }

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/merger/aggregation/NullableAggregationResultSetTest.java

@@ -76,11 +76,11 @@ public class NullableAggregationResultSetTest {
         List<ResultSet> resultSetList = new ArrayList<>();
         if (aggregationType.equals(AggregationColumn.AggregationType.AVG)) {
             resultSetList.add(MergerTestUtil.createMock(Lists.newArrayList(aggregationType.name(), "sharding_gen_1", "sharding_gen_2"), Lists.newArrayList(new Integer[]{null, null, null})));
-            resultSetList.add(MergerTestUtil.createMock(Lists.newArrayList(aggregationType.name(), "sharding_gen_1", "sharding_gen_2"), Lists.newArrayList(new Integer[]{null, 1, 1})));
+            resultSetList.add(MergerTestUtil.createMock(Lists.newArrayList(aggregationType.name(), "sharding_gen_1", "sharding_gen_2"), Lists.newArrayList(null, 1, 1)));
             resultSetList.add(MergerTestUtil.createMock(Lists.newArrayList(aggregationType.name(), "sharding_gen_1", "sharding_gen_2"), Lists.newArrayList(new Integer[]{null, null, null})));
         } else {
             resultSetList.add(MergerTestUtil.createMock(Lists.newArrayList(aggregationType.name()), Lists.newArrayList(new Integer[]{null})));
-            resultSetList.add(MergerTestUtil.createMock(Lists.newArrayList(aggregationType.name()), Lists.newArrayList(new Integer[]{1})));
+            resultSetList.add(MergerTestUtil.createMock(Lists.newArrayList(aggregationType.name()), Lists.newArrayList(1)));
             resultSetList.add(MergerTestUtil.createMock(Lists.newArrayList(aggregationType.name()), Lists.newArrayList(new Integer[]{null})));
         }
         ResultSet resultSet = ResultSetFactory.getResultSet(resultSetList, result);

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/merger/orderby/OrderByValueTest.java

@@ -33,7 +33,7 @@ import com.dangdang.ddframe.rdb.sharding.parser.result.merger.OrderByColumn.Orde
 public final class OrderByValueTest {
     
     @Test
-    public void assertcompareToWithSame() {
+    public void assertCompareToWithSame() {
         List<OrderByColumn> columns = Arrays.asList(new OrderByColumn("col1", OrderByType.ASC), new OrderByColumn("col2", OrderByType.DESC));
         List<Comparable<?>> values = createValues(1, 2);
         OrderByValue.Value orderByValue1 = new OrderByValue.Value(columns, values);
@@ -42,7 +42,7 @@ public final class OrderByValueTest {
     }
     
     @Test
-    public void assertcompareToWithAscForFirstValue() {
+    public void assertCompareToWithAscForFirstValue() {
         List<OrderByColumn> columns = Arrays.asList(new OrderByColumn("col1", OrderByType.ASC), new OrderByColumn("col2", OrderByType.DESC));
         OrderByValue.Value orderByValue1 = new OrderByValue.Value(columns, createValues(1, 2));
         OrderByValue.Value orderByValue2 = new OrderByValue.Value(columns, createValues(2, 2));
@@ -50,7 +50,7 @@ public final class OrderByValueTest {
     }
     
     @Test
-    public void assertcompareToWithDescForFirstValue() {
+    public void assertCompareToWithDescForFirstValue() {
         List<OrderByColumn> columns = Arrays.asList(new OrderByColumn("col1", OrderByType.ASC), new OrderByColumn("col2", OrderByType.DESC));
         OrderByValue.Value orderByValue1 = new OrderByValue.Value(columns, createValues(1, 2));
         OrderByValue.Value orderByValue2 = new OrderByValue.Value(columns, createValues(2, 2));
@@ -58,7 +58,7 @@ public final class OrderByValueTest {
     }
     
     @Test
-    public void assertcompareToWithAscForSecondValue() {
+    public void assertCompareToWithAscForSecondValue() {
         List<OrderByColumn> columns = Arrays.asList(new OrderByColumn("col1", OrderByType.ASC), new OrderByColumn("col2", OrderByType.DESC));
         OrderByValue.Value orderByValue1 = new OrderByValue.Value(columns, createValues(2, 1));
         OrderByValue.Value orderByValue2 = new OrderByValue.Value(columns, createValues(2, 2));
@@ -66,7 +66,7 @@ public final class OrderByValueTest {
     }
     
     @Test
-    public void assertcompareToWithDescForSecondValue() {
+    public void assertCompareToWithDescForSecondValue() {
         List<OrderByColumn> columns = Arrays.asList(new OrderByColumn("col1", OrderByType.ASC), new OrderByColumn("col2", OrderByType.DESC));
         OrderByValue.Value orderByValue1 = new OrderByValue.Value(columns, createValues(2, 1));
         OrderByValue.Value orderByValue2 = new OrderByValue.Value(columns, createValues(2, 2));

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/parser/AbstractBaseParseTest.java

@@ -17,15 +17,6 @@
 
 package com.dangdang.ddframe.rdb.sharding.parser;
 
-import java.io.File;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Iterator;
-import javax.xml.bind.JAXBContext;
-import javax.xml.bind.JAXBException;
-
 import com.dangdang.ddframe.rdb.sharding.parser.jaxb.Assert;
 import com.dangdang.ddframe.rdb.sharding.parser.jaxb.Asserts;
 import com.dangdang.ddframe.rdb.sharding.parser.jaxb.Value;
@@ -50,6 +41,15 @@ import lombok.AccessLevel;
 import lombok.Getter;
 import org.mockito.internal.matchers.apachecommons.ReflectionEquals;
 
+import javax.xml.bind.JAXBContext;
+import javax.xml.bind.JAXBException;
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Iterator;
+
 import static org.hamcrest.CoreMatchers.is;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertThat;
@@ -76,7 +76,7 @@ public abstract class AbstractBaseParseTest {
     
     private final Limit limit;
     
-    public AbstractBaseParseTest(final String testCaseName, final String sql, final String expectedSQL,
+    protected AbstractBaseParseTest(final String testCaseName, final String sql, final String expectedSQL,
                                  final Collection<Table> expectedTables, final Collection<ConditionContext> expectedConditionContext, final MergeContext expectedMergeContext) {
         this.testCaseName = testCaseName;
         this.sql = sql;
@@ -89,7 +89,7 @@ public abstract class AbstractBaseParseTest {
         this.limit = expectedMergeContext.getLimit();
     }
     
-    public static Collection<Object[]> dataParameters(final String path) {
+    protected static Collection<Object[]> dataParameters(final String path) {
         Collection<Object[]> result = new ArrayList<>();
         for (File each : new File(AbstractBaseParseTest.class.getClassLoader().getResource(path).getPath()).listFiles()) {
             result.addAll(dataParameters(each));

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/router/AbstractDynamicRouteSqlTest.java

@@ -17,15 +17,14 @@
 
 package com.dangdang.ddframe.rdb.sharding.router;
 
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.List;
-
 import com.dangdang.ddframe.rdb.sharding.api.HintShardingValueManager;
 import com.dangdang.ddframe.rdb.sharding.exception.SQLParserException;
 import com.dangdang.ddframe.rdb.sharding.parser.result.router.Condition;
 
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+
 public class AbstractDynamicRouteSqlTest extends AbstractBaseRouteSqlTest {
     
     protected void assertSingleTarget(final List<ShardingValuePair> shardingValuePairs, final String originSql, final String targetDataSource, final String targetSQL) throws SQLParserException {
@@ -41,8 +40,7 @@ public class AbstractDynamicRouteSqlTest extends AbstractBaseRouteSqlTest {
         assertMultipleTargets(shardingValuePairs, originSql, Collections.emptyList(), expectedSize, targetDataSources, targetSQLs);
     }
     
-    protected void assertMultipleTargets(final List<ShardingValuePair> shardingValuePairs, final String originSql, final List<Object> parameters, final int expectedSize,
-                                         final Collection<String> targetDataSources, final Collection<String> targetSQLs) throws SQLParserException {
+    private void assertMultipleTargets(final List<ShardingValuePair> shardingValuePairs, final String originSql, final List<Object> parameters, final int expectedSize, final Collection<String> targetDataSources, final Collection<String> targetSQLs) throws SQLParserException {
         HintShardingValueManager.init();
         for (ShardingValuePair each : shardingValuePairs) {
             HintShardingValueManager.registerShardingValueOfDatabase(each.logicTable, "order_id", each.binaryOperator, each.shardingValue);

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/router/single/SingleRouterUtilTest.java

@@ -41,9 +41,9 @@ public class SingleRouterUtilTest {
         condition.getValues().add(2);
         shardingValue = SingleRouterUtil.convertConditionToShardingValue(condition);
         assertThat(shardingValue.getType(), is(ShardingValue.ShardingValueType.LIST));
-        Iterator<?> iter = shardingValue.getValues().iterator();
-        assertThat((Integer) iter.next(), is(1));
-        assertThat((Integer) iter.next(), is(2));
+        Iterator<?> iterator = shardingValue.getValues().iterator();
+        assertThat((Integer) iterator.next(), is(1));
+        assertThat((Integer) iterator.next(), is(2));
         
         condition = new Condition(new Condition.Column("test", "test"), Condition.BinaryOperator.BETWEEN);
         condition.getValues().add(1);

sharding-jdbc-core/src/test/resources/com/dangdang/ddframe/rdb/sharding/parser/mysql/or/select_or.xml

@@ -53,7 +53,7 @@
         </condition-contexts>
     </assert>
     
-    <assert id="assertSelectWithCompictedOrExpression" sql="select id from travelrecord where id = 1 and ( fee=3 or days=5 or (traveldate = '2015-05-04 00:00:07.375' and (user_id=2 or days=2 or fee = 0))) and id=2" expected-sql="SELECT id FROM [Token(travelrecord)] WHERE id = 1 AND (fee = 3 OR days = 5 OR traveldate = '2015-05-04 00:00:07.375' AND (user_id = 2 OR days = 2 OR fee = 0)) AND id = 2">
+    <assert id="assertSelectWithComplicatedOrExpression" sql="select id from travelrecord where id = 1 and ( fee=3 or days=5 or (traveldate = '2015-05-04 00:00:07.375' and (user_id=2 or days=2 or fee = 0))) and id=2" expected-sql="SELECT id FROM [Token(travelrecord)] WHERE id = 1 AND (fee = 3 OR days = 5 OR traveldate = '2015-05-04 00:00:07.375' AND (user_id = 2 OR days = 2 OR fee = 0)) AND id = 2">
         <tables>
             <table name="travelrecord" />
         </tables>
@@ -115,7 +115,7 @@
         </condition-contexts>
     </assert>
     
-    <assert id="assertNullCondtions" sql="select id from travelrecord where 1=1 or id = 1"  expected-sql="SELECT id FROM [Token(travelrecord)] WHERE 1 = 1 OR id = 1">
+    <assert id="assertNullConditions" sql="select id from travelrecord where 1=1 or id = 1"  expected-sql="SELECT id FROM [Token(travelrecord)] WHERE 1 = 1 OR id = 1">
         <tables>
             <table name="travelrecord" />
         </tables>

sharding-jdbc-doc/content/data/chart.js

@@ -79,7 +79,7 @@ var chartData = {
             }
         ]
     }
-}
+};
 
 var charStyle = [
     
@@ -105,4 +105,4 @@ var charStyle = [
         pointHoverBorderColor: "rgba(61,134,198,1)",
         pointHoverBorderWidth: 2,
     }
-]
\ No newline at end of file
+];
\ No newline at end of file

sharding-jdbc-doc/content/index/index.md

@@ -76,10 +76,10 @@ DataSource dataSource = new ShardingDataSource(shardingRule);
 String sql = "SELECT i.* FROM t_order o JOIN t_order_item i ON o.order_id=i.order_id WHERE o.user_id=? AND o.order_id=?";
 try (
         Connection conn = dataSource.getConnection();
-        PreparedStatement pstmt = conn.prepareStatement(sql)) {
-    pstmt.setInt(1, 10);
-    pstmt.setInt(2, 1001);
-    try (ResultSet rs = pstmt.executeQuery()) {
+        PreparedStatement preparedStatement = conn.prepareStatement(sql)) {
+    preparedStatement.setInt(1, 10);
+    preparedStatement.setInt(2, 1001);
+    try (ResultSet rs = preparedStatement.executeQuery()) {
         while(rs.next()) {
             System.out.println(rs.getInt(1));
             System.out.println(rs.getInt(2));

sharding-jdbc-doc/content/post/configuration.md

@@ -299,11 +299,11 @@ data_source_${id.longValue() % 2 + 1}
 
 方法列表如下：
 
-| *方法名*                  | *入参*         | *返回类型* |
-| ------------------------ | -------------- | --------- |
-| longValue()              |                | long      |
-| doubleValue()            |                | double    |
+| *方法名*                  | *入参*         | *返回类型*      |
+| ------------------------ | -------------- | ---------------|
+| longValue()              |                | long           |
+| doubleValue()            |                | double         |
 | dateValue(String format) | 时间格式化表达式 | java.util.Date |
 | dateValue()              |                | java.util.Date |
-| toString(String format)  | 时间格式化表达式 | String |
-| toString()               |                | STring |
+| toString(String format)  | 时间格式化表达式 | String         |
+| toString()               |                | String         |

sharding-jdbc-doc/content/post/hint_shardingvalue.md

@@ -35,11 +35,11 @@ String sql = "SELECT * FROM t_order";
         
 try (
         Connection conn = dataSource.getConnection();
-        PreparedStatement pstmt = conn.prepareStatement(sql)) {
+        PreparedStatement preparedStatement = conn.prepareStatement(sql)) {
     HintShardingValueManager.init();
     HintShardingValueManager.registerShardingValueOfDatabase("t_order", "user_id", 1);
     HintShardingValueManager.registerShardingValueOfTable("t_order", "order_id", 2);
-    try (ResultSet rs = pstmt.executeQuery()) {
+    try (ResultSet rs = preparedStatement.executeQuery()) {
         while (rs.next()) {
             ...
         }

sharding-jdbc-doc/content/post/soft_transaction.md

@@ -73,7 +73,7 @@ weight = 6
 | syncMaxDeliveryTryTimes            | int                                        | 3         | 同步的事务送达的最大尝试次数                                         |
 | asyncMaxDeliveryTryTimes           | int                                        | 3         | 异步的事务送达的最大尝试次数                                         |
 | asyncMaxDeliveryTryDelayMillis     | long                                       | 60000     | 执行异步送达事务的延迟毫秒数。早于此间隔时间的入库事务才会被异步作业执行   |
-| stroageType                        | enum                                       | DATABASE  | 事务日志存储类型。可选值: DATABASE, MEMORY。使用DATABASE类型将自动建表 |
+| storageType                        | enum                                       | DATABASE  | 事务日志存储类型。可选值: DATABASE, MEMORY。使用DATABASE类型将自动建表 |
 | transactionLogDataSource           | DataSource                                 | null      | 存储事务日志的数据源                                                |
 | nestedJob                          | boolean                                    | false     | 是否使用内嵌的作业处理异步事务送达                                    |
 | bestEffortsDeliveryJobConfiguration| AbstractBestEffortsDeliveryJobConfiguration| null      | 最大努力送达型异步作业配置对象                                       |

sharding-jdbc-doc/content/post/stress_test.md

@@ -84,6 +84,6 @@ chart = true
 <canvas id="singleAndDubbleUpdate" width="400" height="150"></canvas>
 
 ## Sharding-JDBC疲劳测试
-经过8个小时的疲劳测试，jvm的堆大约占用不到600MB的内存，且使用量比较稳定。没有发生fullgc。
+经过8个小时的疲劳测试，jvm的堆大约占用不到600MB的内存，且使用量比较稳定。没有发生Full GC。
 <canvas id="fatigueTest" width="400" height="150"></canvas>
 

sharding-jdbc-doc/content/post/user_guide.md

@@ -371,11 +371,11 @@ new ShardingDataSource(shardingRule);
 String sql = "SELECT i.* FROM t_order o JOIN t_order_item i ON o.order_id=i.order_id WHERE o.user_id=? AND o.order_id=?";
         try (
                 Connection conn = dataSource.getConnection();
-                PreparedStatement pstmt = conn.prepareStatement(sql);
+                PreparedStatement preparedStatement = conn.prepareStatement(sql);
                 ) {
-            pstmt.setInt(1, 10);
-            pstmt.setInt(2, 1001);
-            ResultSet rs = pstmt.executeQuery();
+            preparedStatement.setInt(1, 10);
+            preparedStatement.setInt(2, 1001);
+            ResultSet rs = preparedStatement.executeQuery();
             while (rs.next()) {
                 System.out.println(rs.getInt(1));
                 System.out.println(rs.getInt(2));

sharding-jdbc-doc/layouts/partials/js.html

@@ -19,7 +19,7 @@
         var data =  chartData[$(this).attr("id")];
         $(data.datasets).each(function(index, obj){
             $.extend(obj, charStyle[index])
-        })
+        });
         new Chart(this.getContext("2d"),{
             type: 'line',
             data: data

sharding-jdbc-doc/static/css/table.css

@@ -2,7 +2,6 @@ table {
   display: block;
   width: 100%;
   overflow: auto;
-  word-break: normal;
   word-break: keep-all; }
 table th {
     font-weight: bold; }

sharding-jdbc-example/sharding-jdbc-example-config-spring/src/main/java/com/dangdang/ddframe/rdb/sharding/example/config/repository/FooRepositoryImpl.java

@@ -37,21 +37,21 @@ public class FooRepositoryImpl implements FooRepository {
         for (int orderId = 1; orderId <= 4; orderId++) {
             for (int userId = 1; userId <= 2; userId++) {
                 try (Connection connection = shardingDataSource.getConnection()) {
-                    PreparedStatement pstmt = connection.prepareStatement(orderSql);
-                    pstmt.setInt(1, orderId);
-                    pstmt.setInt(2, userId);
-                    pstmt.setString(3, "insert");
-                    pstmt.execute();
-                    pstmt.close();
+                    PreparedStatement preparedStatement = connection.prepareStatement(orderSql);
+                    preparedStatement.setInt(1, orderId);
+                    preparedStatement.setInt(2, userId);
+                    preparedStatement.setString(3, "insert");
+                    preparedStatement.execute();
+                    preparedStatement.close();
                 
-                    pstmt = connection.prepareStatement(orderItemSql);
+                    preparedStatement = connection.prepareStatement(orderItemSql);
                     int orderItemId = orderId + 4;
-                    pstmt.setInt(1, orderItemId);
-                    pstmt.setInt(2, orderId);
-                    pstmt.setInt(3, userId);
-                    pstmt.setString(4, "insert");
-                    pstmt.execute();
-                    pstmt.close();
+                    preparedStatement.setInt(1, orderItemId);
+                    preparedStatement.setInt(2, orderId);
+                    preparedStatement.setInt(3, userId);
+                    preparedStatement.setString(4, "insert");
+                    preparedStatement.execute();
+                    preparedStatement.close();
                 }  catch (Exception ex) {
                     ex.printStackTrace();
                 }
@@ -64,12 +64,12 @@ public class FooRepositoryImpl implements FooRepository {
         String orderSql = "DELETE FROM `t_order`";
         String orderItemSql = "DELETE FROM `t_order_item`";
         try (Connection connection = shardingDataSource.getConnection()) {
-            PreparedStatement pstmt = connection.prepareStatement(orderSql);
-            pstmt.execute();
-            pstmt.close();
-            pstmt = connection.prepareStatement(orderItemSql);
-            pstmt.execute();
-            pstmt.close();
+            PreparedStatement preparedStatement = connection.prepareStatement(orderSql);
+            preparedStatement.execute();
+            preparedStatement.close();
+            preparedStatement = connection.prepareStatement(orderItemSql);
+            preparedStatement.execute();
+            preparedStatement.close();
         } catch (Exception ex) {
             ex.printStackTrace();
         }
@@ -80,10 +80,10 @@ public class FooRepositoryImpl implements FooRepository {
         String sql = "SELECT i.* FROM t_order o JOIN t_order_item i ON o.order_id=i.order_id WHERE o.user_id=? AND o.order_id=?";
         try (
             Connection conn = shardingDataSource.getConnection();
-            PreparedStatement pstmt = conn.prepareStatement(sql)) {
-            pstmt.setInt(1, 1);
-            pstmt.setInt(2, 2);
-            try (ResultSet rs = pstmt.executeQuery()) {
+            PreparedStatement preparedStatement = conn.prepareStatement(sql)) {
+            preparedStatement.setInt(1, 1);
+            preparedStatement.setInt(2, 2);
+            try (ResultSet rs = preparedStatement.executeQuery()) {
                 while(rs.next()) {
                     System.out.println("orderItemId:" + rs.getInt(1) + ",orderId:" + rs.getInt(2) + 
                         ",userId:" + rs.getInt(3) + ",status:" + rs.getString(4));

sharding-jdbc-example/sharding-jdbc-example-config-yaml/src/main/java/com/dangdang/ddframe/rdb/sharding/example/config/YamlConfigMain.java

@@ -39,10 +39,10 @@ public final class YamlConfigMain {
         String sql = "SELECT i.* FROM t_order o JOIN t_order_item i ON o.order_id=i.order_id WHERE o.user_id=? AND o.order_id=?";
         try (
             Connection conn = dataSource.getConnection();
-            PreparedStatement pstmt = conn.prepareStatement(sql)) {
-            pstmt.setInt(1, 10);
-            pstmt.setInt(2, 1001);
-            try (ResultSet rs = pstmt.executeQuery()) {
+            PreparedStatement preparedStatement = conn.prepareStatement(sql)) {
+            preparedStatement.setInt(1, 10);
+            preparedStatement.setInt(2, 1001);
+            try (ResultSet rs = preparedStatement.executeQuery()) {
                 while(rs.next()) {
                     System.out.println(rs.getInt(1));
                     System.out.println(rs.getInt(2));
@@ -56,8 +56,8 @@ public final class YamlConfigMain {
         String sql = "SELECT o.user_id, COUNT(*) FROM t_order o JOIN t_order_item i ON o.order_id=i.order_id GROUP BY o.user_id";
         try (
             Connection conn = dataSource.getConnection();
-            PreparedStatement pstmt = conn.prepareStatement(sql)) {
-            ResultSet rs = pstmt.executeQuery();
+            PreparedStatement preparedStatement = conn.prepareStatement(sql)) {
+            ResultSet rs = preparedStatement.executeQuery();
             while (rs.next()) {
                 System.out.println("user_id: " + rs.getInt(1)+ ", count: " + rs.getInt(2));
             }

sharding-jdbc-example/sharding-jdbc-example-jdbc-transaction/src/main/java/com/dangdang/ddframe/rdb/sharding/example/transaction/Main.java

@@ -17,17 +17,6 @@
 
 package com.dangdang.ddframe.rdb.sharding.example.transaction;
 
-import java.sql.Connection;
-import java.sql.PreparedStatement;
-import java.sql.SQLException;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.Map;
-
-import javax.sql.DataSource;
-
-import org.apache.commons.dbcp.BasicDataSource;
-
 import com.dangdang.ddframe.rdb.sharding.api.ShardingDataSource;
 import com.dangdang.ddframe.rdb.sharding.api.rule.BindingTableRule;
 import com.dangdang.ddframe.rdb.sharding.api.rule.DataSourceRule;
@@ -37,11 +26,21 @@ import com.dangdang.ddframe.rdb.sharding.api.strategy.database.DatabaseShardingS
 import com.dangdang.ddframe.rdb.sharding.api.strategy.table.TableShardingStrategy;
 import com.dangdang.ddframe.rdb.sharding.example.transaction.algorithm.ModuloDatabaseShardingAlgorithm;
 import com.dangdang.ddframe.rdb.sharding.example.transaction.algorithm.ModuloTableShardingAlgorithm;
-import com.dangdang.ddframe.rdb.transaction.soft.bed.BEDSoftTransactionManager;
 import com.dangdang.ddframe.rdb.transaction.soft.api.SoftTransactionManagerFactory;
 import com.dangdang.ddframe.rdb.transaction.soft.api.SoftTransactionType;
 import com.dangdang.ddframe.rdb.transaction.soft.api.config.NestedBestEffortsDeliveryJobConfiguration;
 import com.dangdang.ddframe.rdb.transaction.soft.api.config.SoftTransactionConfiguration;
+import com.dangdang.ddframe.rdb.transaction.soft.bed.BEDSoftTransactionManager;
+import org.apache.commons.dbcp.BasicDataSource;
+
+import javax.sql.DataSource;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
 
 // CHECKSTYLE:OFF
 public final class Main {
@@ -65,13 +64,13 @@ public final class Main {
         try {
             conn = dataSource.getConnection();
             transactionManager.begin(conn);
-            PreparedStatement pstmt1 = conn.prepareStatement(sql1);
-            PreparedStatement pstmt2 = conn.prepareStatement(sql2);
-            pstmt2.setObject(1, 1000);
-            PreparedStatement pstmt3 = conn.prepareStatement(sql3);
-            pstmt1.executeUpdate();
-            pstmt2.executeUpdate();
-            pstmt3.executeUpdate();
+            PreparedStatement preparedStatement1 = conn.prepareStatement(sql1);
+            PreparedStatement preparedStatement2 = conn.prepareStatement(sql2);
+            preparedStatement2.setObject(1, 1000);
+            PreparedStatement preparedStatement3 = conn.prepareStatement(sql3);
+            preparedStatement1.executeUpdate();
+            preparedStatement2.executeUpdate();
+            preparedStatement3.executeUpdate();
         } finally {
             transactionManager.end();
             if (conn != null) {
@@ -80,12 +79,11 @@ public final class Main {
         }
     }
     
-    private static ShardingDataSource getShardingDataSource() throws SQLException {
+    private static ShardingDataSource getShardingDataSource() {
         DataSourceRule dataSourceRule = new DataSourceRule(createDataSourceMap());
         TableRule orderTableRule = new TableRule("t_order", Arrays.asList("t_order_0", "t_order_1"), dataSourceRule);
         TableRule orderItemTableRule = new TableRule("t_order_item", Arrays.asList("t_order_item_0", "t_order_item_1"), dataSourceRule);
-        ShardingRule shardingRule = new ShardingRule(dataSourceRule, Arrays.asList(orderTableRule, orderItemTableRule),
-                Arrays.asList(new BindingTableRule(Arrays.asList(orderTableRule, orderItemTableRule))),
+        ShardingRule shardingRule = new ShardingRule(dataSourceRule, Arrays.asList(orderTableRule, orderItemTableRule), Collections.singletonList(new BindingTableRule(Arrays.asList(orderTableRule, orderItemTableRule))),
                 new DatabaseShardingStrategy("user_id", new ModuloDatabaseShardingAlgorithm()),
                 new TableShardingStrategy("order_id", new ModuloTableShardingAlgorithm()));
         return new ShardingDataSource(shardingRule);

sharding-jdbc-example/sharding-jdbc-example-jdbc/src/main/java/com/dangdang/ddframe/rdb/sharding/example/jdbc/Main.java

@@ -22,6 +22,7 @@ import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 import javax.sql.DataSource;
@@ -54,10 +55,10 @@ public final class Main {
         String sql = "SELECT i.* FROM t_order o JOIN t_order_item i ON o.order_id=i.order_id WHERE o.user_id=? AND o.order_id=?";
         try (
                 Connection conn = dataSource.getConnection();
-                PreparedStatement pstmt = conn.prepareStatement(sql)) {
-            pstmt.setInt(1, 10);
-            pstmt.setInt(2, 1001);
-            try (ResultSet rs = pstmt.executeQuery()) {
+                PreparedStatement preparedStatement = conn.prepareStatement(sql)) {
+            preparedStatement.setInt(1, 10);
+            preparedStatement.setInt(2, 1001);
+            try (ResultSet rs = preparedStatement.executeQuery()) {
                 while (rs.next()) {
                     System.out.println(rs.getInt(1));
                     System.out.println(rs.getInt(2));
@@ -71,9 +72,9 @@ public final class Main {
         String sql = "SELECT o.user_id, COUNT(*) FROM t_order o JOIN t_order_item i ON o.order_id=i.order_id GROUP BY o.user_id";
         try (
                 Connection conn = dataSource.getConnection();
-                PreparedStatement pstmt = conn.prepareStatement(sql)
+                PreparedStatement preparedStatement = conn.prepareStatement(sql)
                 ) {
-            ResultSet rs = pstmt.executeQuery();
+            ResultSet rs = preparedStatement.executeQuery();
             while (rs.next()) {
                 System.out.println("user_id: " + rs.getInt(1) + ", count: " + rs.getInt(2));
             }
@@ -85,11 +86,11 @@ public final class Main {
         
         try (
                 Connection conn = dataSource.getConnection();
-                PreparedStatement pstmt = conn.prepareStatement(sql)) {
+                PreparedStatement preparedStatement = conn.prepareStatement(sql)) {
             HintShardingValueManager.init();
             HintShardingValueManager.registerShardingValueOfDatabase("t_order", "user_id", 10);
             HintShardingValueManager.registerShardingValueOfTable("t_order", "order_id", 1001);
-            try (ResultSet rs = pstmt.executeQuery()) {
+            try (ResultSet rs = preparedStatement.executeQuery()) {
                 while (rs.next()) {
                     System.out.println(rs.getInt(1));
                     System.out.println(rs.getInt(2));
@@ -101,12 +102,11 @@ public final class Main {
         }
     }
     
-    private static ShardingDataSource getShardingDataSource() throws SQLException {
+    private static ShardingDataSource getShardingDataSource() {
         DataSourceRule dataSourceRule = new DataSourceRule(createDataSourceMap());
         TableRule orderTableRule = new TableRule("t_order", Arrays.asList("t_order_0", "t_order_1"), dataSourceRule);
         TableRule orderItemTableRule = new TableRule("t_order_item", Arrays.asList("t_order_item_0", "t_order_item_1"), dataSourceRule);
-        ShardingRule shardingRule = new ShardingRule(dataSourceRule, Arrays.asList(orderTableRule, orderItemTableRule),
-                Arrays.asList(new BindingTableRule(Arrays.asList(orderTableRule, orderItemTableRule))),
+        ShardingRule shardingRule = new ShardingRule(dataSourceRule, Arrays.asList(orderTableRule, orderItemTableRule), Collections.singletonList(new BindingTableRule(Arrays.asList(orderTableRule, orderItemTableRule))),
                 new DatabaseShardingStrategy("user_id", new ModuloDatabaseShardingAlgorithm()),
                 new TableShardingStrategy("order_id", new ModuloTableShardingAlgorithm()));
         return new ShardingDataSource(shardingRule);

sharding-jdbc-example/sharding-jdbc-example-jdbc/src/main/java/com/dangdang/ddframe/rdb/sharding/example/jdbc/algorithm/ModuloDatabaseShardingAlgorithm.java

@@ -52,7 +52,7 @@ public final class ModuloDatabaseShardingAlgorithm implements SingleKeyDatabaseS
     @Override
     public Collection<String> doBetweenSharding(final Collection<String> dataSourceNames, final ShardingValue<Integer> shardingValue) {
         Collection<String> result = new LinkedHashSet<>(dataSourceNames.size());
-        Range<Integer> range = (Range<Integer>) shardingValue.getValueRange();
+        Range<Integer> range = shardingValue.getValueRange();
         for (Integer i = range.lowerEndpoint(); i <= range.upperEndpoint(); i++) {
             for (String each : dataSourceNames) {
                 if (each.endsWith(i % 2 + "")) {

sharding-jdbc-example/sharding-jdbc-example-jpa/src/main/java/com/dangdang/ddframe/rdb/sharding/example/jdbc/algorithm/SingleKeyModuloDatabaseShardingAlgorithm.java

@@ -39,7 +39,7 @@ public final class SingleKeyModuloDatabaseShardingAlgorithm implements SingleKey
     @Override
     public Collection<String> doInSharding(final Collection<String> availableTargetNames, final ShardingValue<Integer> shardingValue) {
         Collection<String> result = new LinkedHashSet<>(availableTargetNames.size());
-        Collection<Integer> values = (Collection<Integer>) shardingValue.getValues();
+        Collection<Integer> values = shardingValue.getValues();
         for (Integer value : values) {
             for (String dataSourceName : availableTargetNames) {
                 if (dataSourceName.endsWith(value % 2 + "")) {
@@ -53,7 +53,7 @@ public final class SingleKeyModuloDatabaseShardingAlgorithm implements SingleKey
     @Override
     public Collection<String> doBetweenSharding(final Collection<String> availableTargetNames, final ShardingValue<Integer> shardingValue) {
         Collection<String> result = new LinkedHashSet<>(availableTargetNames.size());
-        Range<Integer> range = (Range<Integer>) shardingValue.getValueRange();
+        Range<Integer> range = shardingValue.getValueRange();
         for (Integer i = range.lowerEndpoint(); i <= range.upperEndpoint(); i++) {
             for (String each : availableTargetNames) {
                 if (each.endsWith(i % 2 + "")) {

sharding-jdbc-example/sharding-jdbc-example-jpa/src/main/resources/META-INF/shardingContext.xml

 <?xml version="1.0" encoding="UTF-8"?>
 <beans xmlns="http://www.springframework.org/schema/beans"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-    xmlns:context="http://www.springframework.org/schema/context"
     xsi:schemaLocation="http://www.springframework.org/schema/beans
                         http://www.springframework.org/schema/beans/spring-beans.xsd">
     <bean id="ds_0" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">

sharding-jdbc-example/sharding-jdbc-example-mybatis/src/main/java/com/dangdang/ddframe/rdb/sharding/example/jdbc/algorithm/SingleKeyModuloDatabaseShardingAlgorithm.java

@@ -39,7 +39,7 @@ public final class SingleKeyModuloDatabaseShardingAlgorithm implements SingleKey
     @Override
     public Collection<String> doInSharding(final Collection<String> availableTargetNames, final ShardingValue<Integer> shardingValue) {
         Collection<String> result = new LinkedHashSet<>(availableTargetNames.size());
-        Collection<Integer> values = (Collection<Integer>) shardingValue.getValues();
+        Collection<Integer> values = shardingValue.getValues();
         for (Integer value : values) {
             for (String dataSourceName : availableTargetNames) {
                 if (dataSourceName.endsWith(value % 2 + "")) {
@@ -53,7 +53,7 @@ public final class SingleKeyModuloDatabaseShardingAlgorithm implements SingleKey
     @Override
     public Collection<String> doBetweenSharding(final Collection<String> availableTargetNames, final ShardingValue<Integer> shardingValue) {
         Collection<String> result = new LinkedHashSet<>(availableTargetNames.size());
-        Range<Integer> range = (Range<Integer>) shardingValue.getValueRange();
+        Range<Integer> range = shardingValue.getValueRange();
         for (Integer i = range.lowerEndpoint(); i <= range.upperEndpoint(); i++) {
             for (String each : availableTargetNames) {
                 if (each.endsWith(i % 2 + "")) {

sharding-jdbc-transaction-async-job/src/main/java/com/dangdang/ddframe/rdb/transaction/soft/AsyncJobMain.java

@@ -58,7 +58,7 @@ public final class AsyncJobMain {
         new BestEffortsDeliveryJobFactory(transactionConfig).init();
     }
     
-    private static ShardingDataSource getShardingDataSource() throws SQLException {
+    private static ShardingDataSource getShardingDataSource() {
         DataSourceRule dataSourceRule = new DataSourceRule(createDataSourceMap());
         TableRule orderTableRule = new TableRule("t_order", Arrays.asList("t_order_0", "t_order_1"), dataSourceRule);
         TableRule orderItemTableRule = new TableRule("t_order_item", Arrays.asList("t_order_item_0", "t_order_item_1"), dataSourceRule);

sharding-jdbc-transaction/src/main/java/com/dangdang/ddframe/rdb/transaction/soft/api/SoftTransactionManagerFactory.java

@@ -22,7 +22,7 @@ import com.dangdang.ddframe.rdb.transaction.soft.api.config.SoftTransactionConfi
 import com.dangdang.ddframe.rdb.transaction.soft.bed.BEDSoftTransactionManager;
 import com.dangdang.ddframe.rdb.transaction.soft.bed.async.NestedBestEffortsDeliveryJobFactory;
 import com.dangdang.ddframe.rdb.transaction.soft.bed.sync.BestEffortsDeliveryListener;
-import com.dangdang.ddframe.rdb.transaction.soft.storage.TransactionLogStroageType;
+import com.dangdang.ddframe.rdb.transaction.soft.storage.TransactionLogStorageType;
 import com.dangdang.ddframe.rdb.transaction.soft.tcc.TCCSoftTransactionManager;
 import com.google.common.base.Optional;
 import com.google.common.base.Preconditions;
@@ -53,7 +53,7 @@ public final class SoftTransactionManagerFactory {
      */
     public void init() throws SQLException {
         DMLExecutionEventBus.register(new BestEffortsDeliveryListener());
-        if (TransactionLogStroageType.DATABASE == transactionConfig.getStroageType()) {
+        if (TransactionLogStorageType.DATABASE == transactionConfig.getStorageType()) {
             Preconditions.checkNotNull(transactionConfig.getTransactionLogDataSource());
             createTable();
         }
@@ -74,8 +74,8 @@ public final class SoftTransactionManagerFactory {
                 + "PRIMARY KEY (`id`));";
         try (
                 Connection conn = transactionConfig.getTransactionLogDataSource().getConnection();
-                PreparedStatement psmt = conn.prepareStatement(dbSchema)) {
-            psmt.executeUpdate();
+                PreparedStatement preparedStatement = conn.prepareStatement(dbSchema)) {
+            preparedStatement.executeUpdate();
         }
     }
     

sharding-jdbc-transaction/src/main/java/com/dangdang/ddframe/rdb/transaction/soft/api/config/SoftTransactionConfiguration.java

@@ -20,7 +20,7 @@ package com.dangdang.ddframe.rdb.transaction.soft.api.config;
 import javax.sql.DataSource;
 
 import com.dangdang.ddframe.rdb.sharding.api.ShardingDataSource;
-import com.dangdang.ddframe.rdb.transaction.soft.storage.TransactionLogStroageType;
+import com.dangdang.ddframe.rdb.transaction.soft.storage.TransactionLogStorageType;
 
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
@@ -61,7 +61,7 @@ public final class SoftTransactionConfiguration {
     /**
      * 事务日志存储类型.
      */
-    private TransactionLogStroageType stroageType = TransactionLogStroageType.DATABASE;
+    private TransactionLogStorageType storageType = TransactionLogStorageType.DATABASE;
     
     /**
      * 存储事务日志的数据源.

sharding-jdbc-transaction/src/main/java/com/dangdang/ddframe/rdb/transaction/soft/bed/async/AbstractBestEffortsDeliveryJobFactory.java

@@ -21,7 +21,7 @@ import com.dangdang.ddframe.job.api.JobConfiguration;
 import com.dangdang.ddframe.job.api.JobScheduler;
 import com.dangdang.ddframe.rdb.transaction.soft.api.config.AbstractBestEffortsDeliveryJobConfiguration;
 import com.dangdang.ddframe.rdb.transaction.soft.api.config.SoftTransactionConfiguration;
-import com.dangdang.ddframe.rdb.transaction.soft.storage.TransacationLogStorageFactory;
+import com.dangdang.ddframe.rdb.transaction.soft.storage.TransactionLogStorageFactory;
 import com.dangdang.ddframe.reg.base.CoordinatorRegistryCenter;
 import com.dangdang.ddframe.reg.zookeeper.ZookeeperConfiguration;
 import com.dangdang.ddframe.reg.zookeeper.ZookeeperRegistryCenter;
@@ -48,7 +48,7 @@ public abstract class AbstractBestEffortsDeliveryJobFactory<T extends AbstractBe
         regCenter.init();
         JobScheduler jobScheduler = new JobScheduler(regCenter, createBedJobConfiguration(bedJobConfig));
         jobScheduler.setField("transactionConfig", transactionConfig);
-        jobScheduler.setField("transacationLogStorage", TransacationLogStorageFactory.createTransacationLogStorageFactory(transactionConfig));
+        jobScheduler.setField("transactionLogStorage", TransactionLogStorageFactory.createTransactionLogStorageFactory(transactionConfig));
         jobScheduler.init();
     }
     

sharding-jdbc-transaction/src/main/java/com/dangdang/ddframe/rdb/transaction/soft/bed/async/BestEffortsDeliveryJob.java

@@ -26,7 +26,7 @@ import com.dangdang.ddframe.job.api.JobExecutionMultipleShardingContext;
 import com.dangdang.ddframe.job.plugin.job.type.dataflow.AbstractIndividualThroughputDataFlowElasticJob;
 import com.dangdang.ddframe.rdb.transaction.soft.api.SoftTransactionType;
 import com.dangdang.ddframe.rdb.transaction.soft.api.config.SoftTransactionConfiguration;
-import com.dangdang.ddframe.rdb.transaction.soft.storage.TransacationLogStorage;
+import com.dangdang.ddframe.rdb.transaction.soft.storage.TransactionLogStorage;
 import com.dangdang.ddframe.rdb.transaction.soft.storage.TransactionLog;
 
 import lombok.Setter;
@@ -44,28 +44,28 @@ public class BestEffortsDeliveryJob extends AbstractIndividualThroughputDataFlow
     private SoftTransactionConfiguration transactionConfig;
     
     @Setter
-    private TransacationLogStorage transacationLogStorage;
+    private TransactionLogStorage transactionLogStorage;
     
     @Override
     public List<TransactionLog> fetchData(final JobExecutionMultipleShardingContext context) {
-        return transacationLogStorage.findEligibledTransactionLogs(context.getFetchDataCount(), SoftTransactionType.BestEffortsDelivery);
+        return transactionLogStorage.findEligibleTransactionLogs(context.getFetchDataCount(), SoftTransactionType.BestEffortsDelivery);
     }
     
     @Override
     public boolean processData(final JobExecutionMultipleShardingContext context, final TransactionLog data) {
         try (
                 Connection conn = transactionConfig.getTargetDataSource().getConnection().getConnection(data.getDataSource());
-                PreparedStatement pstmt = conn.prepareStatement(data.getSql())) {
+                PreparedStatement preparedStatement = conn.prepareStatement(data.getSql())) {
             for (int parameterIndex = 0; parameterIndex < data.getParameters().size(); parameterIndex++) {
-                pstmt.setObject(parameterIndex + 1, data.getParameters().get(parameterIndex));
+                preparedStatement.setObject(parameterIndex + 1, data.getParameters().get(parameterIndex));
             }
-            pstmt.executeUpdate();
+            preparedStatement.executeUpdate();
         } catch (final SQLException ex) {
-            transacationLogStorage.increaseAsyncDeliveryTryTimes(data.getId());
+            transactionLogStorage.increaseAsyncDeliveryTryTimes(data.getId());
             log.error(String.format("Async delivery times %s error, max try times is %s", data.getAsyncDeliveryTryTimes() + 1, transactionConfig.getAsyncMaxDeliveryTryTimes()), ex);
             return false;
         }
-        transacationLogStorage.remove(data.getId());
+        transactionLogStorage.remove(data.getId());
         return true;
     }
     

sharding-jdbc-transaction/src/main/java/com/dangdang/ddframe/rdb/transaction/soft/bed/sync/BestEffortsDeliveryListener.java

@@ -28,8 +28,8 @@ import com.dangdang.ddframe.rdb.transaction.soft.bed.BEDSoftTransactionManager;
 import com.dangdang.ddframe.rdb.transaction.soft.api.SoftTransactionManagerFactory;
 import com.dangdang.ddframe.rdb.transaction.soft.api.SoftTransactionType;
 import com.dangdang.ddframe.rdb.transaction.soft.api.config.SoftTransactionConfiguration;
-import com.dangdang.ddframe.rdb.transaction.soft.storage.TransacationLogStorage;
-import com.dangdang.ddframe.rdb.transaction.soft.storage.TransacationLogStorageFactory;
+import com.dangdang.ddframe.rdb.transaction.soft.storage.TransactionLogStorage;
+import com.dangdang.ddframe.rdb.transaction.soft.storage.TransactionLogStorageFactory;
 import com.dangdang.ddframe.rdb.transaction.soft.storage.TransactionLog;
 import com.google.common.eventbus.AllowConcurrentEvents;
 import com.google.common.eventbus.Subscribe;
@@ -51,15 +51,15 @@ public final class BestEffortsDeliveryListener implements DMLExecutionEventListe
             return;
         }
         SoftTransactionConfiguration transactionConfig = SoftTransactionManagerFactory.getCurrentTransactionConfiguration().get();
-        TransacationLogStorage transacationLogStorage = TransacationLogStorageFactory.createTransacationLogStorageFactory(transactionConfig);
+        TransactionLogStorage transactionLogStorage = TransactionLogStorageFactory.createTransactionLogStorageFactory(transactionConfig);
         BEDSoftTransactionManager transactionManager = (BEDSoftTransactionManager) SoftTransactionManagerFactory.getCurrentTransactionManager().get();
         switch (event.getEventExecutionType()) {
             case BEFORE_EXECUTE: 
-                transacationLogStorage.add(new TransactionLog(
+                transactionLogStorage.add(new TransactionLog(
                         event.getId(), transactionManager.getTransactionId(), transactionManager.getTransactionType(), event.getDataSource(), event.getSql(), event.getParameters(), System.currentTimeMillis(), 0));
                 return;
             case EXECUTE_SUCCESS: 
-                transacationLogStorage.remove(event.getId());
+                transactionLogStorage.remove(event.getId());
                 return;
             case EXECUTE_FAILURE: 
                 boolean deliverySuccess = false;
@@ -69,24 +69,24 @@ public final class BestEffortsDeliveryListener implements DMLExecutionEventListe
                     }
                     boolean isNewConnection = false;
                     Connection conn = null;
-                    PreparedStatement pstmt = null;
+                    PreparedStatement preparedStatement = null;
                     try {
                         conn = transactionManager.getConnection().getConnection(event.getDataSource());
                         if (!isValidConnection(conn)) {
                             conn = transactionManager.getConnection();
                             isNewConnection = true;
                         }
-                        pstmt = conn.prepareStatement(event.getSql());
+                        preparedStatement = conn.prepareStatement(event.getSql());
                         for (int parameterIndex = 0; parameterIndex < event.getParameters().size(); parameterIndex++) {
-                            pstmt.setObject(parameterIndex + 1, event.getParameters().get(parameterIndex));
+                            preparedStatement.setObject(parameterIndex + 1, event.getParameters().get(parameterIndex));
                         }
-                        pstmt.executeUpdate();
+                        preparedStatement.executeUpdate();
                         deliverySuccess = true;
-                        transacationLogStorage.remove(event.getId());
+                        transactionLogStorage.remove(event.getId());
                     } catch (final SQLException ex) {
                         log.error(String.format("Delivery times %s error, max try times is %s", i + 1, transactionConfig.getSyncMaxDeliveryTryTimes()), ex);
                     } finally {
-                        close(isNewConnection, conn, pstmt);
+                        close(isNewConnection, conn, preparedStatement);
                     }
                 }
                 return;
@@ -101,8 +101,8 @@ public final class BestEffortsDeliveryListener implements DMLExecutionEventListe
     }
     
     private boolean isValidConnection(final Connection conn) {
-        try (PreparedStatement pstmt = conn.prepareStatement("SELECT 1")) {
-            try (ResultSet rs = pstmt.executeQuery()) {
+        try (PreparedStatement preparedStatement = conn.prepareStatement("SELECT 1")) {
+            try (ResultSet rs = preparedStatement.executeQuery()) {
                 return rs.next() && 1 == rs.getInt("1");
             }
         } catch (final SQLException ex) {
@@ -110,19 +110,19 @@ public final class BestEffortsDeliveryListener implements DMLExecutionEventListe
         }
     }
     
-    private void close(final boolean isNewConnection, final Connection conn, final PreparedStatement pstmt) {
-        if (null != pstmt) {
+    private void close(final boolean isNewConnection, final Connection conn, final PreparedStatement preparedStatement) {
+        if (null != preparedStatement) {
             try {
-                pstmt.close();
+                preparedStatement.close();
             } catch (final SQLException ex) {
-                log.error("PreparedStatement colsed error:", ex);
+                log.error("PreparedStatement closed error:", ex);
             }
         }
         if (isNewConnection && null != conn) {
             try {
                 conn.close();
             } catch (final SQLException ex) {
-                log.error("Connection colsed error:", ex);
+                log.error("Connection closed error:", ex);
             }
         }
     }

sharding-jdbc-transaction/src/main/java/com/dangdang/ddframe/rdb/transaction/soft/storage/TransacationLogStorage.java → sharding-jdbc-transaction/src/main/java/com/dangdang/ddframe/rdb/transaction/soft/storage/TransactionLogStorage.java

@@ -26,7 +26,7 @@ import com.dangdang.ddframe.rdb.transaction.soft.api.SoftTransactionType;
  * 
  * @author zhangliang
  */
-public interface TransacationLogStorage {
+public interface TransactionLogStorage {
     
     /**
      * 存储事务日志.
@@ -52,7 +52,7 @@ public interface TransacationLogStorage {
      * @param size 获取日志的数量
      * @param type 柔性事务类型
      */
-    List<TransactionLog> findEligibledTransactionLogs(int size, SoftTransactionType type);
+    List<TransactionLog> findEligibleTransactionLogs(int size, SoftTransactionType type);
     
     /**
      * 增加事务日志异步重试次数.

sharding-jdbc-transaction/src/main/java/com/dangdang/ddframe/rdb/transaction/soft/storage/TransacationLogStorageFactory.java → sharding-jdbc-transaction/src/main/java/com/dangdang/ddframe/rdb/transaction/soft/storage/TransactionLogStorageFactory.java

@@ -18,8 +18,8 @@
 package com.dangdang.ddframe.rdb.transaction.soft.storage;
 
 import com.dangdang.ddframe.rdb.transaction.soft.api.config.SoftTransactionConfiguration;
-import com.dangdang.ddframe.rdb.transaction.soft.storage.impl.DatabaseTransacationLogStorage;
-import com.dangdang.ddframe.rdb.transaction.soft.storage.impl.MemoryTransacationLogStorage;
+import com.dangdang.ddframe.rdb.transaction.soft.storage.impl.DatabaseTransactionLogStorage;
+import com.dangdang.ddframe.rdb.transaction.soft.storage.impl.MemoryTransactionLogStorage;
 
 import lombok.AccessLevel;
 import lombok.NoArgsConstructor;
@@ -30,7 +30,7 @@ import lombok.NoArgsConstructor;
  * @author zhangliang
  */
 @NoArgsConstructor(access = AccessLevel.PRIVATE)
-public final class TransacationLogStorageFactory {
+public final class TransactionLogStorageFactory {
     
     /**
      * 创建事务日志存储器.
@@ -38,14 +38,14 @@ public final class TransacationLogStorageFactory {
      * @param transactionConfiguration 柔性事务配置对象
      * @return 事务日志存储器
      */
-    public static TransacationLogStorage createTransacationLogStorageFactory(final SoftTransactionConfiguration transactionConfiguration) {
-        switch (transactionConfiguration.getStroageType()) {
+    public static TransactionLogStorage createTransactionLogStorageFactory(final SoftTransactionConfiguration transactionConfiguration) {
+        switch (transactionConfiguration.getStorageType()) {
             case MEMORY: 
-                return new MemoryTransacationLogStorage(transactionConfiguration);
+                return new MemoryTransactionLogStorage(transactionConfiguration);
             case DATABASE: 
-                return new DatabaseTransacationLogStorage(transactionConfiguration, transactionConfiguration);
+                return new DatabaseTransactionLogStorage(transactionConfiguration, transactionConfiguration);
             default: 
-                throw new UnsupportedOperationException(transactionConfiguration.getStroageType().toString());
+                throw new UnsupportedOperationException(transactionConfiguration.getStorageType().toString());
         }
     }
 }

sharding-jdbc-transaction/src/main/java/com/dangdang/ddframe/rdb/transaction/soft/storage/TransactionLogStroageType.java → sharding-jdbc-transaction/src/main/java/com/dangdang/ddframe/rdb/transaction/soft/storage/TransactionLogStorageType.java

@@ -22,7 +22,7 @@ package com.dangdang.ddframe.rdb.transaction.soft.storage;
  * 
  * @author zhangliang
  */
-public enum TransactionLogStroageType {
+public enum TransactionLogStorageType {
     
     /**
      *  内存存储.

sharding-jdbc-transaction/src/main/java/com/dangdang/ddframe/rdb/transaction/soft/storage/impl/DatabaseTransacationLogStorage.java → sharding-jdbc-transaction/src/main/java/com/dangdang/ddframe/rdb/transaction/soft/storage/impl/DatabaseTransactionLogStorage.java

@@ -19,7 +19,7 @@ package com.dangdang.ddframe.rdb.transaction.soft.storage.impl;
 
 import com.dangdang.ddframe.rdb.transaction.soft.api.SoftTransactionType;
 import com.dangdang.ddframe.rdb.transaction.soft.api.config.SoftTransactionConfiguration;
-import com.dangdang.ddframe.rdb.transaction.soft.storage.TransacationLogStorage;
+import com.dangdang.ddframe.rdb.transaction.soft.storage.TransactionLogStorage;
 import com.dangdang.ddframe.rdb.transaction.soft.storage.TransactionLog;
 import com.google.gson.Gson;
 import com.google.gson.reflect.TypeToken;
@@ -40,7 +40,7 @@ import java.util.List;
  */
 @RequiredArgsConstructor
 @Slf4j
-public final class DatabaseTransacationLogStorage implements TransacationLogStorage {
+public final class DatabaseTransactionLogStorage implements TransactionLogStorage {
     
     private final SoftTransactionConfiguration transactionConfiguration;
     
@@ -51,14 +51,14 @@ public final class DatabaseTransacationLogStorage implements TransacationLogStor
         String sql = "INSERT INTO `transaction_log` (`id`, `transaction_type`, `data_source`, `sql`, `parameters`, `creation_time`) VALUES (?, ?, ?, ?, ?, ?);";
         try (
                 Connection conn = transactionConfiguration.getTransactionLogDataSource().getConnection();
-                PreparedStatement psmt = conn.prepareStatement(sql)) {
-            psmt.setString(1, transactionLog.getId());
-            psmt.setString(2, transactionLog.getTransactionType().toString());
-            psmt.setString(3, transactionLog.getDataSource());
-            psmt.setString(4, transactionLog.getSql());
-            psmt.setString(5, new Gson().toJson(transactionLog.getParameters()));
-            psmt.setLong(6, transactionLog.getCreationTime());
-            psmt.executeUpdate();
+                PreparedStatement preparedStatement = conn.prepareStatement(sql)) {
+            preparedStatement.setString(1, transactionLog.getId());
+            preparedStatement.setString(2, transactionLog.getTransactionType().toString());
+            preparedStatement.setString(3, transactionLog.getDataSource());
+            preparedStatement.setString(4, transactionLog.getSql());
+            preparedStatement.setString(5, new Gson().toJson(transactionLog.getParameters()));
+            preparedStatement.setLong(6, transactionLog.getCreationTime());
+            preparedStatement.executeUpdate();
         } catch (final SQLException ex) {
             log.error("Save transaction log error:", ex);
         }
@@ -69,26 +69,26 @@ public final class DatabaseTransacationLogStorage implements TransacationLogStor
         String sql = "DELETE FROM `transaction_log` WHERE `id`=?;";
         try (
                 Connection conn = transactionConfiguration.getTransactionLogDataSource().getConnection();
-                PreparedStatement psmt = conn.prepareStatement(sql)) {
-            psmt.setString(1, id);
-            psmt.executeUpdate();
+                PreparedStatement preparedStatement = conn.prepareStatement(sql)) {
+            preparedStatement.setString(1, id);
+            preparedStatement.executeUpdate();
         } catch (final SQLException ex) {
             log.error("Delete transaction log error:", ex);
         }
     }
     
     @Override
-    public List<TransactionLog> findEligibledTransactionLogs(final int size, final SoftTransactionType type) {
+    public List<TransactionLog> findEligibleTransactionLogs(final int size, final SoftTransactionType type) {
         List<TransactionLog> result = new ArrayList<>(size);
         String sql = "SELECT `id`, `transaction_type`, `data_source`, `sql`, `parameters`, `creation_time`, `async_delivery_try_times` "
                 + "FROM `transaction_log` WHERE `async_delivery_try_times`<? AND `transaction_type`=? AND `creation_time`<? LIMIT ?;";
         try (
                 Connection conn = transactionConfiguration.getTransactionLogDataSource().getConnection();
-                PreparedStatement psmt = conn.prepareStatement(sql)) {
-            psmt.setInt(1, transactionConfig.getAsyncMaxDeliveryTryTimes());
-            psmt.setString(2, type.toString());
-            psmt.setLong(3, System.currentTimeMillis() - transactionConfiguration.getAsyncMaxDeliveryTryDelayMillis());
-            try (ResultSet rs = psmt.executeQuery()) {
+                PreparedStatement preparedStatement = conn.prepareStatement(sql)) {
+            preparedStatement.setInt(1, transactionConfig.getAsyncMaxDeliveryTryTimes());
+            preparedStatement.setString(2, type.toString());
+            preparedStatement.setLong(3, System.currentTimeMillis() - transactionConfiguration.getAsyncMaxDeliveryTryDelayMillis());
+            try (ResultSet rs = preparedStatement.executeQuery()) {
                 while (rs.next()) {
                     Gson gson = new Gson();
                     List<Object> parameters = gson.fromJson(rs.getString(5), new TypeToken<List<Object>>() { }.getType());
@@ -106,9 +106,9 @@ public final class DatabaseTransacationLogStorage implements TransacationLogStor
         String sql = "UPDATE `transaction_log` SET `async_delivery_try_times`=`async_delivery_try_times`+1 WHERE `id`=?;";
         try (
                 Connection conn = transactionConfiguration.getTransactionLogDataSource().getConnection();
-                PreparedStatement psmt = conn.prepareStatement(sql)) {
-            psmt.setString(1, id);
-            psmt.executeUpdate();
+                PreparedStatement preparedStatement = conn.prepareStatement(sql)) {
+            preparedStatement.setString(1, id);
+            preparedStatement.executeUpdate();
         } catch (final SQLException ex) {
             log.error("Update transaction log error:", ex);
         }

sharding-jdbc-transaction/src/main/java/com/dangdang/ddframe/rdb/transaction/soft/storage/impl/MemoryTransacationLogStorage.java → sharding-jdbc-transaction/src/main/java/com/dangdang/ddframe/rdb/transaction/soft/storage/impl/MemoryTransactionLogStorage.java

@@ -23,7 +23,7 @@ import java.util.concurrent.ConcurrentHashMap;
 
 import com.dangdang.ddframe.rdb.transaction.soft.api.SoftTransactionType;
 import com.dangdang.ddframe.rdb.transaction.soft.api.config.SoftTransactionConfiguration;
-import com.dangdang.ddframe.rdb.transaction.soft.storage.TransacationLogStorage;
+import com.dangdang.ddframe.rdb.transaction.soft.storage.TransactionLogStorage;
 import com.dangdang.ddframe.rdb.transaction.soft.storage.TransactionLog;
 
 import lombok.RequiredArgsConstructor;
@@ -34,7 +34,7 @@ import lombok.RequiredArgsConstructor;
  * @author zhangliang
  */
 @RequiredArgsConstructor
-public final class MemoryTransacationLogStorage implements TransacationLogStorage {
+public final class MemoryTransactionLogStorage implements TransactionLogStorage {
     
     private static final ConcurrentHashMap<String, TransactionLog> DATA = new ConcurrentHashMap<>();
     
@@ -51,7 +51,7 @@ public final class MemoryTransacationLogStorage implements TransacationLogStorag
     }
     
     @Override
-    public List<TransactionLog> findEligibledTransactionLogs(final int size, final SoftTransactionType type) {
+    public List<TransactionLog> findEligibleTransactionLogs(final int size, final SoftTransactionType type) {
         List<TransactionLog> result = new ArrayList<>();
         int count = 0;
         for (TransactionLog each : DATA.values()) {