fix sharding rule config to json

sharding-jdbc-orchestration/src/main/java/com/dangdang/ddframe/rdb/sharding/api/OrchestrationShardingDataSourceFactory.java

@@ -21,6 +21,7 @@ import com.dangdang.ddframe.rdb.sharding.api.config.ShardingRuleConfig;
 import com.dangdang.ddframe.rdb.sharding.jdbc.core.datasource.ShardingDataSource;
 import com.dangdang.ddframe.rdb.sharding.json.DataSourceJsonConverter;
 import com.dangdang.ddframe.rdb.sharding.json.GsonFactory;
+import com.dangdang.ddframe.rdb.sharding.json.ShardingRuleConfigConverter;
 import com.dangdang.ddframe.rdb.sharding.reg.base.CoordinatorRegistryCenter;
 import com.google.common.base.Charsets;
 import lombok.AccessLevel;
@@ -105,11 +106,16 @@ public final class OrchestrationShardingDataSourceFactory {
                 if (path.isEmpty()) {
                     return;
                 }
-                if (("/" + name + "/config/sharding").equals(path) || ("/" + name + "/config/datasource").equals(path)) {
-                    ShardingRuleConfig newShardingRuleConfig = GsonFactory.getGson().fromJson(new String(childData.getData(), Charsets.UTF_8), ShardingRuleConfig.class);
+                if (("/" + name + "/config/datasource").equals(path)) {
                     Map<String, DataSource> newDataSourceMap = DataSourceJsonConverter.fromJson(new String(childData.getData(), Charsets.UTF_8));
+                    ShardingRuleConfig shardingRuleConfig = ShardingRuleConfigConverter.fromJson(registryCenter.get("/" + name + "/config/sharding"));
                     // TODO props
-                    shardingDataSource.renew(newShardingRuleConfig.build(newDataSourceMap), new Properties());
+                    shardingDataSource.renew(shardingRuleConfig.build(newDataSourceMap), new Properties());
+                } else if (("/" + name + "/config/sharding").equals(path)) {
+                    ShardingRuleConfig newShardingRuleConfig = ShardingRuleConfigConverter.fromJson(new String(childData.getData(), Charsets.UTF_8));
+                    Map<String, DataSource> dataSourceMap = DataSourceJsonConverter.fromJson(registryCenter.get("/" + name + "/config/datasource"));
+                    // TODO props
+                    shardingDataSource.renew(newShardingRuleConfig.build(dataSourceMap), new Properties());
                 }
             }
         });

sharding-jdbc-orchestration/src/main/java/com/dangdang/ddframe/rdb/sharding/json/DataSourceGsonTypeAdapter.java

@@ -32,7 +32,7 @@ import java.util.Map.Entry;
 import java.util.TreeMap;
 
 /**
- * 作业配置的Json转换适配器.
+ * Data source gson type adapter.
  *
  * @author zhangliang
  */

sharding-jdbc-orchestration/src/main/java/com/dangdang/ddframe/rdb/sharding/json/DataSourceJsonConverter.java

@@ -46,7 +46,7 @@ public final class DataSourceJsonConverter {
      * Convert data source map to json.
      * 
      * @param dataSources data source map
-     * @return sharding rule configuration json string
+     * @return data source map json string
      */
     public static String toJson(final Map<String, DataSource> dataSources) {
         Collection<NamedDataSource> result = new LinkedList<>();

sharding-jdbc-orchestration/src/main/java/com/dangdang/ddframe/rdb/sharding/json/ShardingRuleConfigConverter.java

+/*
+ * Copyright 1999-2015 dangdang.com.
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * </p>
+ */
+
+package com.dangdang.ddframe.rdb.sharding.json;
+
+import com.dangdang.ddframe.rdb.sharding.api.config.ShardingRuleConfig;
+import com.dangdang.ddframe.rdb.sharding.api.config.strategy.ShardingStrategyConfig;
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+
+/**
+ * Sharding rule configuration json converter.
+ *
+ * @author zhangliang
+ */
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+public final class ShardingRuleConfigConverter {
+    
+    static {
+        GsonFactory.registerTypeAdapter(ShardingStrategyConfig.class, new ShardingStrategyConfigGsonTypeAdapter());
+    }
+    
+    /**
+     * Convert sharding rule configuration to json.
+     * 
+     * @param shardingRuleConfig sharding rule configuration
+     * @return sharding rule configuration json string
+     */
+    public static String toJson(final ShardingRuleConfig shardingRuleConfig) {
+        return GsonFactory.getGson().toJson(shardingRuleConfig);
+    }
+    
+    /**
+     * Convert sharding rule configuration from json.
+     *
+     * @param json sharding rule configuration json string
+     * @return sharding rule configuration
+     */
+    public static ShardingRuleConfig fromJson(final String json) {
+        return GsonFactory.getGson().fromJson(json, ShardingRuleConfig.class);
+    }
+}

sharding-jdbc-orchestration/src/main/java/com/dangdang/ddframe/rdb/sharding/json/ShardingStrategyConfigGsonTypeAdapter.java

+/*
+ * Copyright 1999-2015 dangdang.com.
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * </p>
+ */
+
+package com.dangdang.ddframe.rdb.sharding.json;
+
+import com.dangdang.ddframe.rdb.sharding.api.config.strategy.ComplexShardingStrategyConfig;
+import com.dangdang.ddframe.rdb.sharding.api.config.strategy.HintShardingStrategyConfig;
+import com.dangdang.ddframe.rdb.sharding.api.config.strategy.InlineShardingStrategyConfig;
+import com.dangdang.ddframe.rdb.sharding.api.config.strategy.NoneShardingStrategyConfig;
+import com.dangdang.ddframe.rdb.sharding.api.config.strategy.ShardingStrategyConfig;
+import com.dangdang.ddframe.rdb.sharding.api.config.strategy.StandardShardingStrategyConfig;
+import com.dangdang.ddframe.rdb.sharding.exception.ShardingJdbcException;
+import com.google.gson.TypeAdapter;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonWriter;
+
+import java.io.IOException;
+
+/**
+ * Sharding strategy configuration gson type adapter.
+ *
+ * @author zhangliang
+ */
+public final class ShardingStrategyConfigGsonTypeAdapter extends TypeAdapter<ShardingStrategyConfig> {
+    
+    @Override
+    public ShardingStrategyConfig read(final JsonReader in) throws IOException {
+        String type = "";
+        String shardingColumn = "";
+        String shardingColumns = "";
+        String algorithmClassName = "";
+        String preciseAlgorithmClassName = "";
+        String rangeAlgorithmClassName = "";
+        String algorithmInlineExpression = "";
+        in.beginObject();
+        while (in.hasNext()) {
+            String jsonName = in.nextName();
+            switch (jsonName) {
+                case "type":
+                    type = in.nextString();
+                    break;
+                case "shardingColumn":
+                    shardingColumn = in.nextString();
+                    break;
+                case "shardingColumns":
+                    shardingColumns = in.nextString();
+                    break;
+                case "algorithmClassName":
+                    algorithmClassName = in.nextString();
+                    break;
+                case "preciseAlgorithmClassName":
+                    preciseAlgorithmClassName = in.nextString();
+                    break;
+                case "rangeAlgorithmClassName":
+                    rangeAlgorithmClassName = in.nextString();
+                    break;
+                case "algorithmInlineExpression":
+                    algorithmInlineExpression = in.nextString();
+                    break;
+                default:
+                    throw new ShardingJdbcException("Cannot convert json for property: %s", jsonName);
+            }
+        }
+        in.endObject();
+        return createStrategy(type, shardingColumn, shardingColumns, algorithmClassName, preciseAlgorithmClassName, rangeAlgorithmClassName, algorithmInlineExpression); 
+    }
+    
+    private ShardingStrategyConfig createStrategy(final String type, final String shardingColumn, final String shardingColumns, 
+                                                  final String algorithmClassName, final String preciseAlgorithmClassName, final String rangeAlgorithmClassName, 
+                                                  final String algorithmInlineExpression) {
+        if (type.equals(ShardingStrategyType.STANDARD.name())) {
+            return createStandardStrategy(shardingColumn, preciseAlgorithmClassName, rangeAlgorithmClassName);
+        }
+        if (type.equals(ShardingStrategyType.COMPLEX.name())) {
+            return createComplexStrategy(shardingColumns, algorithmClassName);
+        }
+        if (type.equals(ShardingStrategyType.INLINE.name())) {
+            return createInlineStrategy(shardingColumn, algorithmInlineExpression);
+        }
+        if (type.equals(ShardingStrategyType.HINT.name())) {
+            return createHintStrategy(algorithmClassName);
+        }
+        if (type.equals(ShardingStrategyType.NONE.name())) {
+            return new NoneShardingStrategyConfig();
+        }
+        return null;
+    }
+    
+    private ShardingStrategyConfig createStandardStrategy(final String shardingColumn, final String preciseAlgorithmClassName, final String rangeAlgorithmClassName) {
+        StandardShardingStrategyConfig result = new StandardShardingStrategyConfig();
+        result.setShardingColumn(shardingColumn);
+        result.setPreciseAlgorithmClassName(preciseAlgorithmClassName);
+        result.setRangeAlgorithmClassName(rangeAlgorithmClassName);
+        return result;
+    }
+    
+    private ShardingStrategyConfig createComplexStrategy(final String shardingColumns, final String algorithmClassName) {
+        ComplexShardingStrategyConfig result = new ComplexShardingStrategyConfig();
+        result.setShardingColumns(shardingColumns);
+        result.setAlgorithmClassName(algorithmClassName);
+        return result;
+    }
+    
+    private ShardingStrategyConfig createInlineStrategy(final String shardingColumn, final String algorithmInlineExpression) {
+        InlineShardingStrategyConfig result = new InlineShardingStrategyConfig();
+        result.setShardingColumn(shardingColumn);
+        result.setAlgorithmInlineExpression(algorithmInlineExpression);
+        return result;
+    }
+    
+    private ShardingStrategyConfig createHintStrategy(final String algorithmClassName) {
+        HintShardingStrategyConfig result = new HintShardingStrategyConfig();
+        result.setAlgorithmClassName(algorithmClassName);
+        return result;
+    }
+    
+    @Override
+    public void write(final JsonWriter out, final ShardingStrategyConfig value) throws IOException {
+        out.beginObject();
+        if (value instanceof StandardShardingStrategyConfig) {
+            out.name("type").value(ShardingStrategyType.STANDARD.name());
+            StandardShardingStrategyConfig shardingStrategyConfig = (StandardShardingStrategyConfig) value;
+            out.name("shardingColumn").value(shardingStrategyConfig.getShardingColumn());
+            out.name("preciseAlgorithmClassName").value(shardingStrategyConfig.getPreciseAlgorithmClassName());
+            out.name("rangeAlgorithmClassName").value(shardingStrategyConfig.getRangeAlgorithmClassName());
+        } else if (value instanceof ComplexShardingStrategyConfig) {
+            out.name("type").value(ShardingStrategyType.COMPLEX.name());
+            ComplexShardingStrategyConfig shardingStrategyConfig = (ComplexShardingStrategyConfig) value;
+            out.name("shardingColumns").value(shardingStrategyConfig.getShardingColumns());
+            out.name("algorithmClassName").value(shardingStrategyConfig.getAlgorithmClassName());
+        } else if (value instanceof InlineShardingStrategyConfig) {
+            out.name("type").value(ShardingStrategyType.INLINE.name());
+            InlineShardingStrategyConfig shardingStrategyConfig = (InlineShardingStrategyConfig) value;
+            out.name("shardingColumn").value(shardingStrategyConfig.getShardingColumn());
+            out.name("algorithmInlineExpression").value(shardingStrategyConfig.getAlgorithmInlineExpression());
+        } else if (value instanceof HintShardingStrategyConfig) {
+            out.name("type").value(ShardingStrategyType.HINT.name());
+            HintShardingStrategyConfig shardingStrategyConfig = (HintShardingStrategyConfig) value;
+            out.name("algorithmClassName").value(shardingStrategyConfig.getAlgorithmClassName());
+        } else if (value instanceof NoneShardingStrategyConfig) {
+            out.name("type").value(ShardingStrategyType.NONE.name());
+        }
+        out.endObject();
+    }
+    
+    private enum ShardingStrategyType {
+        
+        STANDARD, COMPLEX, INLINE, HINT, NONE
+    }
+}

sharding-jdbc-orchestration/src/test/java/com/dangdang/ddframe/rdb/sharding/json/DataSourceJsonConverterTest.java

@@ -48,10 +48,10 @@ public final class DataSourceJsonConverterTest {
     
     @Test
     public void assertFromJson() {
-        Map<String, DataSource> dataSources = DataSourceJsonConverter.fromJson(dataSourceMapJson);
-        assertThat(dataSources.size(), is(2));
-        assertDataSource((BasicDataSource) dataSources.get("ds_jdbc_0"), (BasicDataSource) createDataSource("ds_jdbc_0"));
-        assertDataSource((BasicDataSource) dataSources.get("ds_jdbc_1"), (BasicDataSource) createDataSource("ds_jdbc_1"));
+        Map<String, DataSource> actual = DataSourceJsonConverter.fromJson(dataSourceMapJson);
+        assertThat(actual.size(), is(2));
+        assertDataSource((BasicDataSource) actual.get("ds_jdbc_0"), (BasicDataSource) createDataSource("ds_jdbc_0"));
+        assertDataSource((BasicDataSource) actual.get("ds_jdbc_1"), (BasicDataSource) createDataSource("ds_jdbc_1"));
     }
     
     private void assertDataSource(final BasicDataSource actual, final BasicDataSource expect) {
@@ -61,7 +61,6 @@ public final class DataSourceJsonConverterTest {
         assertThat(actual.getRemoveAbandonedTimeout(), is(expect.getRemoveAbandonedTimeout()));
     }
     
-    
     private Map<String, DataSource> createDataSourceMap() {
         Map<String, DataSource> result = new HashMap<>(2, 1);
         result.put("ds_jdbc_0", createDataSource("ds_jdbc_0"));

sharding-jdbc-orchestration/src/test/java/com/dangdang/ddframe/rdb/sharding/json/ShardingRuleConfigConverterTest.java

+package com.dangdang.ddframe.rdb.sharding.json;
+
+import com.dangdang.ddframe.rdb.sharding.api.config.ShardingRuleConfig;
+import com.dangdang.ddframe.rdb.sharding.api.config.TableRuleConfig;
+import com.dangdang.ddframe.rdb.sharding.api.config.strategy.ComplexShardingStrategyConfig;
+import com.dangdang.ddframe.rdb.sharding.api.config.strategy.HintShardingStrategyConfig;
+import com.dangdang.ddframe.rdb.sharding.api.config.strategy.InlineShardingStrategyConfig;
+import com.dangdang.ddframe.rdb.sharding.api.config.strategy.NoneShardingStrategyConfig;
+import com.dangdang.ddframe.rdb.sharding.api.config.strategy.ShardingStrategyConfig;
+import com.dangdang.ddframe.rdb.sharding.api.config.strategy.StandardShardingStrategyConfig;
+import org.junit.Test;
+
+import java.util.Iterator;
+
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThat;
+
+public final class ShardingRuleConfigConverterTest {
+    
+    private final String commonShardingRuleConfigJson = "{\"tableRuleConfigs\":[{\"logicTable\":\"t_order\",\"dynamic\":false,\"actualTables\":\"t_order_${[0, 1]}\","
+            + "\"databaseShardingStrategyConfig\":{},\"tableShardingStrategyConfig\":{}},"
+            + "{\"logicTable\":\"t_order_item\",\"dynamic\":false,\"actualTables\":\"t_order_item_${[0, 1]}\","
+            + "\"databaseShardingStrategyConfig\":{},\"tableShardingStrategyConfig\":{}}"
+            + "],\"bindingTableGroups\":[\"t_order, t_order_item\"],\"defaultDatabaseShardingStrategyConfig\":{},";
+    
+    @Test
+    public void assertToJsonForStandardStrategy() {
+        StandardShardingStrategyConfig actual = new StandardShardingStrategyConfig();
+        actual.setShardingColumn("order_id");
+        actual.setPreciseAlgorithmClassName("xxx.XXXPreciseAlgorithm");
+        actual.setRangeAlgorithmClassName("xxx.XXXRangeAlgorithm");
+        assertThat(ShardingRuleConfigConverter.toJson(getCommonShardingRuleConfig(actual)), is(getJsonForStandardStrategy()));
+    }
+    
+    @Test
+    public void assertToJsonForComplexStrategy() {
+        ComplexShardingStrategyConfig actual = new ComplexShardingStrategyConfig();
+        actual.setShardingColumns("order_id,item_id");
+        actual.setAlgorithmClassName("xxx.XXXAlgorithm");
+        assertThat(ShardingRuleConfigConverter.toJson(getCommonShardingRuleConfig(actual)), is(getJsonForComplexStrategy()));
+    }
+    
+    @Test
+    public void assertToJsonForInlineStrategy() {
+        InlineShardingStrategyConfig actual = new InlineShardingStrategyConfig();
+        actual.setShardingColumn("order_id");
+        actual.setAlgorithmInlineExpression("order_${user_id % 2}");
+        assertThat(ShardingRuleConfigConverter.toJson(getCommonShardingRuleConfig(actual)), is(getJsonForInlineStrategy()));
+    }
+    
+    @Test
+    public void assertToJsonForHintStrategy() {
+        HintShardingStrategyConfig actual = new HintShardingStrategyConfig();
+        actual.setAlgorithmClassName("xxx.XXXAlgorithm");
+        assertThat(ShardingRuleConfigConverter.toJson(getCommonShardingRuleConfig(actual)), is(getJsonForHintStrategy()));
+    }
+    
+    @Test
+    public void assertToJsonForNoneStrategy() {
+        NoneShardingStrategyConfig actual = new NoneShardingStrategyConfig();
+        assertThat(ShardingRuleConfigConverter.toJson(getCommonShardingRuleConfig(actual)), is(getJsonForNoneStrategy()));
+    }
+    
+    private ShardingRuleConfig getCommonShardingRuleConfig(final ShardingStrategyConfig strategyConfig) {
+        ShardingRuleConfig actual = new ShardingRuleConfig();
+        TableRuleConfig orderTableRuleConfig = new TableRuleConfig();
+        orderTableRuleConfig.setLogicTable("t_order");
+        orderTableRuleConfig.setActualTables("t_order_${[0, 1]}");
+        actual.getTableRuleConfigs().add(orderTableRuleConfig);
+        TableRuleConfig orderItemTableRuleConfig = new TableRuleConfig();
+        orderItemTableRuleConfig.setLogicTable("t_order_item");
+        orderItemTableRuleConfig.setActualTables("t_order_item_${[0, 1]}");
+        actual.getTableRuleConfigs().add(orderItemTableRuleConfig);
+        actual.getBindingTableGroups().add("t_order, t_order_item");
+        actual.setDefaultTableShardingStrategyConfig(strategyConfig);
+        return actual;
+    }
+    
+    @Test
+    public void assertFromJsonForStandardStrategy() {
+        ShardingRuleConfig actual = ShardingRuleConfigConverter.fromJson(getJsonForStandardStrategy());
+        assertCommon(actual);
+        StandardShardingStrategyConfig actualShardingStrategy = (StandardShardingStrategyConfig) actual.getDefaultTableShardingStrategyConfig();
+        assertThat(actualShardingStrategy.getShardingColumn(), is("order_id"));
+        assertThat(actualShardingStrategy.getPreciseAlgorithmClassName(), is("xxx.XXXPreciseAlgorithm"));
+        assertThat(actualShardingStrategy.getRangeAlgorithmClassName(), is("xxx.XXXRangeAlgorithm"));
+    }
+    
+    @Test
+    public void assertFromJsonForComplexStrategy() {
+        ShardingRuleConfig actual = ShardingRuleConfigConverter.fromJson(getJsonForComplexStrategy());
+        assertCommon(actual);
+        ComplexShardingStrategyConfig actualShardingStrategy = (ComplexShardingStrategyConfig) actual.getDefaultTableShardingStrategyConfig();
+        assertThat(actualShardingStrategy.getShardingColumns(), is("order_id,item_id"));
+        assertThat(actualShardingStrategy.getAlgorithmClassName(), is("xxx.XXXAlgorithm"));
+    }
+    
+    @Test
+    public void assertFromJsonForInlineStrategy() {
+        ShardingRuleConfig actual = ShardingRuleConfigConverter.fromJson(getJsonForInlineStrategy());
+        assertCommon(actual);
+        InlineShardingStrategyConfig actualShardingStrategy = (InlineShardingStrategyConfig) actual.getDefaultTableShardingStrategyConfig();
+        assertThat(actualShardingStrategy.getShardingColumn(), is("order_id"));
+        assertThat(actualShardingStrategy.getAlgorithmInlineExpression(), is("order_${user_id % 2}"));
+    }
+    
+    @Test
+    public void assertFromJsonForHintStrategy() {
+        ShardingRuleConfig actual = ShardingRuleConfigConverter.fromJson(getJsonForHintStrategy());
+        assertCommon(actual);
+        HintShardingStrategyConfig actualShardingStrategy = (HintShardingStrategyConfig) actual.getDefaultTableShardingStrategyConfig();
+        assertThat(actualShardingStrategy.getAlgorithmClassName(), is("xxx.XXXAlgorithm"));
+    }
+    
+    @Test
+    public void assertFromJsonForNoneStrategy() {
+        ShardingRuleConfig actual = ShardingRuleConfigConverter.fromJson(getJsonForNoneStrategy());
+        assertCommon(actual);
+        assertThat(actual.getDefaultTableShardingStrategyConfig(), instanceOf(NoneShardingStrategyConfig.class));
+    }
+    
+    @Test
+    public void assertFromJsonForNullStrategy() {
+        String actualJson = commonShardingRuleConfigJson + "\"defaultTableShardingStrategyConfig\":{\"type\":\"XXX\"}}";
+        ShardingRuleConfig actual = ShardingRuleConfigConverter.fromJson(actualJson);
+        assertCommon(actual);
+        assertNull(actual.getDefaultTableShardingStrategyConfig());
+    }
+    
+    private String getJsonForStandardStrategy() {
+        return commonShardingRuleConfigJson
+                + "\"defaultTableShardingStrategyConfig\":{\"type\":\"STANDARD\",\"shardingColumn\":\"order_id\","
+                + "\"preciseAlgorithmClassName\":\"xxx.XXXPreciseAlgorithm\",\"rangeAlgorithmClassName\":\"xxx.XXXRangeAlgorithm\"}}";
+    }
+    
+    private String getJsonForComplexStrategy() {
+        return commonShardingRuleConfigJson + "\"defaultTableShardingStrategyConfig\":{\"type\":\"COMPLEX\",\"shardingColumns\":\"order_id,item_id\",\"algorithmClassName\":\"xxx.XXXAlgorithm\"}}";
+    }
+    
+    private String getJsonForInlineStrategy() {
+        return commonShardingRuleConfigJson + "\"defaultTableShardingStrategyConfig\":{\"type\":\"INLINE\",\"shardingColumn\":\"order_id\",\"algorithmInlineExpression\":\"order_${user_id % 2}\"}}";
+    }
+    
+    private String getJsonForHintStrategy() {
+        return commonShardingRuleConfigJson + "\"defaultTableShardingStrategyConfig\":{\"type\":\"HINT\",\"algorithmClassName\":\"xxx.XXXAlgorithm\"}}";
+    }
+    
+    private String getJsonForNoneStrategy() {
+        return commonShardingRuleConfigJson + "\"defaultTableShardingStrategyConfig\":{\"type\":\"NONE\"}}";
+    }
+    
+    private void assertCommon(final ShardingRuleConfig actual) {
+        assertThat(actual.getTableRuleConfigs().size(), is(2));
+        Iterator<TableRuleConfig> actualTableRuleConfigs = actual.getTableRuleConfigs().iterator();
+        TableRuleConfig orderTableRuleConfig = actualTableRuleConfigs.next();
+        assertThat(orderTableRuleConfig.getLogicTable(), is("t_order"));
+        assertThat(orderTableRuleConfig.getActualTables(), is("t_order_${[0, 1]}"));
+        TableRuleConfig orderItemTableRuleConfig = actualTableRuleConfigs.next();
+        assertThat(orderItemTableRuleConfig.getLogicTable(), is("t_order_item"));
+        assertThat(orderItemTableRuleConfig.getActualTables(), is("t_order_item_${[0, 1]}"));
+        assertThat(actual.getBindingTableGroups().size(), is(1));
+        assertThat(actual.getBindingTableGroups().iterator().next(), is("t_order, t_order_item"));
+    }
+}