refactor sharding strategy api

sharding-jdbc-core/src/main/java/io/shardingjdbc/core/api/config/strategy/ComplexShardingStrategyConfiguration.java

@@ -17,27 +17,27 @@
 
 package io.shardingjdbc.core.api.config.strategy;
 
+import com.google.common.base.Preconditions;
+import io.shardingjdbc.core.api.algorithm.sharding.complex.ComplexKeysShardingAlgorithm;
 import io.shardingjdbc.core.routing.strategy.ShardingAlgorithmFactory;
 import io.shardingjdbc.core.routing.strategy.ShardingStrategy;
-import io.shardingjdbc.core.api.algorithm.sharding.complex.ComplexKeysShardingAlgorithm;
 import io.shardingjdbc.core.routing.strategy.complex.ComplexShardingStrategy;
 import io.shardingjdbc.core.util.StringUtil;
-import com.google.common.base.Preconditions;
 import lombok.Getter;
-import lombok.Setter;
+import lombok.RequiredArgsConstructor;
 
 /**
  * Complex sharding strategy configuration.
  * 
  * @author zhangliang
  */
+@RequiredArgsConstructor
 @Getter
-@Setter
-public class ComplexShardingStrategyConfiguration implements ShardingStrategyConfiguration {
+public final class ComplexShardingStrategyConfiguration implements ShardingStrategyConfiguration {
     
-    private String shardingColumns;
+    private final String shardingColumns;
     
-    private String algorithmClassName;
+    private final String algorithmClassName;
     
     @Override
     public ShardingStrategy build() {

sharding-jdbc-core/src/main/java/io/shardingjdbc/core/api/config/strategy/HintShardingStrategyConfiguration.java

@@ -17,24 +17,24 @@
 
 package io.shardingjdbc.core.api.config.strategy;
 
+import com.google.common.base.Preconditions;
+import io.shardingjdbc.core.api.algorithm.sharding.hint.HintShardingAlgorithm;
 import io.shardingjdbc.core.routing.strategy.ShardingAlgorithmFactory;
 import io.shardingjdbc.core.routing.strategy.ShardingStrategy;
-import io.shardingjdbc.core.api.algorithm.sharding.hint.HintShardingAlgorithm;
 import io.shardingjdbc.core.routing.strategy.hint.HintShardingStrategy;
-import com.google.common.base.Preconditions;
 import lombok.Getter;
-import lombok.Setter;
+import lombok.RequiredArgsConstructor;
 
 /**
  * Hint sharding strategy configuration.
  * 
  * @author zhangliang
  */
+@RequiredArgsConstructor
 @Getter
-@Setter
-public class HintShardingStrategyConfiguration implements ShardingStrategyConfiguration {
+public final class HintShardingStrategyConfiguration implements ShardingStrategyConfiguration {
     
-    private String algorithmClassName;
+    private final String algorithmClassName;
     
     @Override
     public ShardingStrategy build() {

sharding-jdbc-core/src/main/java/io/shardingjdbc/core/api/config/strategy/InlineShardingStrategyConfiguration.java

@@ -17,24 +17,24 @@
 
 package io.shardingjdbc.core.api.config.strategy;
 
+import com.google.common.base.Preconditions;
 import io.shardingjdbc.core.routing.strategy.ShardingStrategy;
 import io.shardingjdbc.core.routing.strategy.inline.InlineShardingStrategy;
-import com.google.common.base.Preconditions;
 import lombok.Getter;
-import lombok.Setter;
+import lombok.RequiredArgsConstructor;
 
 /**
  * Inline sharding strategy configuration.
  * 
  * @author zhangliang
  */
+@RequiredArgsConstructor
 @Getter
-@Setter
 public final class InlineShardingStrategyConfiguration implements ShardingStrategyConfiguration {
     
-    private String shardingColumn;
+    private final String shardingColumn;
     
-    private String algorithmInlineExpression;
+    private final String algorithmInlineExpression;
     
     @Override
     public ShardingStrategy build() {

sharding-jdbc-core/src/main/java/io/shardingjdbc/core/api/config/strategy/NoneShardingStrategyConfiguration.java

@@ -19,16 +19,12 @@ package io.shardingjdbc.core.api.config.strategy;
 
 import io.shardingjdbc.core.routing.strategy.ShardingStrategy;
 import io.shardingjdbc.core.routing.strategy.none.NoneShardingStrategy;
-import lombok.Getter;
-import lombok.Setter;
 
 /**
  * None sharding strategy configuration.
  * 
  * @author zhangliang
  */
-@Getter
-@Setter
 public final class NoneShardingStrategyConfiguration implements ShardingStrategyConfiguration {
     
     @Override

sharding-jdbc-core/src/main/java/io/shardingjdbc/core/api/config/strategy/StandardShardingStrategyConfiguration.java

@@ -17,30 +17,34 @@
 
 package io.shardingjdbc.core.api.config.strategy;
 
-import io.shardingjdbc.core.routing.strategy.ShardingAlgorithmFactory;
-import io.shardingjdbc.core.routing.strategy.ShardingStrategy;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Strings;
 import io.shardingjdbc.core.api.algorithm.sharding.standard.PreciseShardingAlgorithm;
 import io.shardingjdbc.core.api.algorithm.sharding.standard.RangeShardingAlgorithm;
+import io.shardingjdbc.core.routing.strategy.ShardingAlgorithmFactory;
+import io.shardingjdbc.core.routing.strategy.ShardingStrategy;
 import io.shardingjdbc.core.routing.strategy.standard.StandardShardingStrategy;
-import com.google.common.base.Preconditions;
-import com.google.common.base.Strings;
 import lombok.Getter;
-import lombok.Setter;
+import lombok.RequiredArgsConstructor;
 
 /**
  * Standard strategy configuration.
  * 
  * @author zhangliang
  */
+@RequiredArgsConstructor
 @Getter
-@Setter
-public class StandardShardingStrategyConfiguration implements ShardingStrategyConfiguration {
+public final class StandardShardingStrategyConfiguration implements ShardingStrategyConfiguration {
     
-    private String shardingColumn;
+    private final String shardingColumn;
     
-    private String preciseAlgorithmClassName;
+    private final String preciseAlgorithmClassName;
     
-    private String rangeAlgorithmClassName;
+    private final String rangeAlgorithmClassName;
+    
+    public StandardShardingStrategyConfiguration(final String shardingColumn, final String preciseAlgorithmClassName) {
+        this(shardingColumn, preciseAlgorithmClassName, null);
+    }
     
     @Override
     public ShardingStrategy build() {

sharding-jdbc-core/src/main/java/io/shardingjdbc/core/yaml/sharding/ShardingRuleBuilder.java → sharding-jdbc-core/src/main/java/io/shardingjdbc/core/yaml/sharding/YamlShardingConfiguration.java

@@ -21,52 +21,71 @@ import io.shardingjdbc.core.api.config.MasterSlaveRuleConfiguration;
 import io.shardingjdbc.core.api.config.ShardingRuleConfiguration;
 import io.shardingjdbc.core.rule.ShardingRule;
 import io.shardingjdbc.core.yaml.masterslave.YamlMasterSlaveConfig;
-import lombok.RequiredArgsConstructor;
+import lombok.Getter;
+import lombok.Setter;
 
 import javax.sql.DataSource;
 import java.sql.SQLException;
+import java.util.ArrayList;
 import java.util.Collection;
+import java.util.HashMap;
 import java.util.LinkedList;
+import java.util.List;
 import java.util.Map;
-import java.util.Map.Entry;
+import java.util.Properties;
 
 /**
- * Sharding rule builder from yaml.
+ * Sharding configuration for yaml.
  *
  * @author caohao
- * @author zhangliang
  */
-@RequiredArgsConstructor
-public final class ShardingRuleBuilder {
+@Getter
+@Setter
+public class YamlShardingConfiguration {
     
-    private final Map<String, DataSource> dataSourceMap;
+    private Map<String, DataSource> dataSources = new HashMap<>();
     
-    private final YamlShardingConfig yamlShardingConfig;
+    private String defaultDataSourceName;
+    
+    private Map<String, YamlTableRuleConfiguration> tables = new HashMap<>();
+    
+    private List<String> bindingTables = new ArrayList<>();
+    
+    private YamlShardingStrategyConfiguration defaultDatabaseStrategy;
+    
+    private YamlShardingStrategyConfiguration defaultTableStrategy;
+    
+    private String defaultKeyGeneratorClass;
+    
+    private Map<String, YamlMasterSlaveConfig> masterSlaveRules = new HashMap<>();
+    
+    private Properties props = new Properties();
     
     /**
      * Build sharding rule from yaml.
-     * 
+     *
+     * @param dataSourceMap data source map
      * @return sharding rule from yaml
      * @throws SQLException SQL exception
      */
-    public ShardingRule build() throws SQLException {
+    public ShardingRule build(final Map<String, DataSource> dataSourceMap) throws SQLException {
         ShardingRuleConfiguration result = new ShardingRuleConfiguration();
-        result.setDefaultDataSourceName(yamlShardingConfig.getDefaultDataSourceName());
-        for (Entry<String, YamlTableRuleConfig> entry : yamlShardingConfig.getTables().entrySet()) {
-            YamlTableRuleConfig tableRuleConfig = entry.getValue();
+        result.setDefaultDataSourceName(defaultDataSourceName);
+        for (Map.Entry<String, YamlTableRuleConfiguration> entry : tables.entrySet()) {
+            YamlTableRuleConfiguration tableRuleConfig = entry.getValue();
             tableRuleConfig.setLogicTable(entry.getKey());
-            result.getTableRuleConfigs().add(tableRuleConfig.getTableRuleConfig());
+            result.getTableRuleConfigs().add(tableRuleConfig.build());
         }
-        result.getBindingTableGroups().addAll(yamlShardingConfig.getBindingTables());
-        if (null != yamlShardingConfig.getDefaultDatabaseStrategy()) {
-            result.setDefaultDatabaseShardingStrategyConfig(yamlShardingConfig.getDefaultDatabaseStrategy().getShardingStrategy());
+        result.getBindingTableGroups().addAll(bindingTables);
+        if (null != defaultDatabaseStrategy) {
+            result.setDefaultDatabaseShardingStrategyConfig(defaultDatabaseStrategy.build());
         }
-        if (null != yamlShardingConfig.getDefaultTableStrategy()) {
-            result.setDefaultTableShardingStrategyConfig(yamlShardingConfig.getDefaultTableStrategy().getShardingStrategy());
+        if (null != defaultTableStrategy) {
+            result.setDefaultTableShardingStrategyConfig(defaultTableStrategy.build());
         }
-        result.setDefaultKeyGeneratorClass(yamlShardingConfig.getDefaultKeyGeneratorClass());
+        result.setDefaultKeyGeneratorClass(defaultKeyGeneratorClass);
         Collection<MasterSlaveRuleConfiguration> masterSlaveRuleConfigs = new LinkedList<>();
-        for (Entry<String, YamlMasterSlaveConfig> each : yamlShardingConfig.getMasterSlaveRules().entrySet()) {
+        for (Map.Entry<String, YamlMasterSlaveConfig> each : masterSlaveRules.entrySet()) {
             MasterSlaveRuleConfiguration config = new MasterSlaveRuleConfiguration();
             config.setName(each.getKey());
             config.setMasterDataSourceName(each.getValue().getMasterDataSourceName());
@@ -76,6 +95,6 @@ public final class ShardingRuleBuilder {
             masterSlaveRuleConfigs.add(config);
         }
         result.setMasterSlaveRuleConfigs(masterSlaveRuleConfigs);
-        return result.build(dataSourceMap.isEmpty() ? yamlShardingConfig.getDataSources() : dataSourceMap);
+        return result.build(dataSourceMap.isEmpty() ? dataSources : dataSourceMap);
     }
 }

sharding-jdbc-core/src/main/java/io/shardingjdbc/core/yaml/sharding/YamlShardingDataSource.java

@@ -39,31 +39,31 @@ import java.util.Map;
 public class YamlShardingDataSource extends ShardingDataSource {
     
     public YamlShardingDataSource(final File yamlFile) throws IOException, SQLException {
-        super(new ShardingRuleBuilder(Collections.<String, DataSource>emptyMap(), unmarshal(yamlFile)).build(), unmarshal(yamlFile).getProps());
+        super(unmarshal(yamlFile).build(Collections.<String, DataSource>emptyMap()), unmarshal(yamlFile).getProps());
     }
     
     public YamlShardingDataSource(final Map<String, DataSource> dataSourceMap, final File yamlFile) throws IOException, SQLException {
-        super(new ShardingRuleBuilder(dataSourceMap, unmarshal(yamlFile)).build(), unmarshal(yamlFile).getProps());
+        super(unmarshal(yamlFile).build(dataSourceMap), unmarshal(yamlFile).getProps());
     }
     
     public YamlShardingDataSource(final byte[] yamlByteArray) throws IOException, SQLException {
-        super(new ShardingRuleBuilder(Collections.<String, DataSource>emptyMap(), unmarshal(yamlByteArray)).build(), unmarshal(yamlByteArray).getProps());
+        super(unmarshal(yamlByteArray).build(Collections.<String, DataSource>emptyMap()), unmarshal(yamlByteArray).getProps());
     }
     
     public YamlShardingDataSource(final Map<String, DataSource> dataSourceMap, final byte[] yamlByteArray) throws IOException, SQLException {
-        super(new ShardingRuleBuilder(dataSourceMap, unmarshal(yamlByteArray)).build(), unmarshal(yamlByteArray).getProps());
+        super(unmarshal(yamlByteArray).build(dataSourceMap), unmarshal(yamlByteArray).getProps());
     }
     
-    private static YamlShardingConfig unmarshal(final File yamlFile) throws IOException {
+    private static YamlShardingConfiguration unmarshal(final File yamlFile) throws IOException {
         try (
                 FileInputStream fileInputStream = new FileInputStream(yamlFile);
                 InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream, "UTF-8")
         ) {
-            return new Yaml(new Constructor(YamlShardingConfig.class)).loadAs(inputStreamReader, YamlShardingConfig.class);
+            return new Yaml(new Constructor(YamlShardingConfiguration.class)).loadAs(inputStreamReader, YamlShardingConfiguration.class);
         }
     }
     
-    private static YamlShardingConfig unmarshal(final byte[] yamlByteArray) throws IOException {
-        return new Yaml(new Constructor(YamlShardingConfig.class)).loadAs(new ByteArrayInputStream(yamlByteArray), YamlShardingConfig.class);
+    private static YamlShardingConfiguration unmarshal(final byte[] yamlByteArray) throws IOException {
+        return new Yaml(new Constructor(YamlShardingConfiguration.class)).loadAs(new ByteArrayInputStream(yamlByteArray), YamlShardingConfiguration.class);
     }
 }

sharding-jdbc-core/src/main/java/io/shardingjdbc/core/yaml/sharding/YamlShardingStrategyConfig.java → sharding-jdbc-core/src/main/java/io/shardingjdbc/core/yaml/sharding/YamlShardingStrategyConfiguration.java

@@ -7,6 +7,11 @@ import io.shardingjdbc.core.api.config.strategy.InlineShardingStrategyConfigurat
 import io.shardingjdbc.core.api.config.strategy.NoneShardingStrategyConfiguration;
 import io.shardingjdbc.core.api.config.strategy.ShardingStrategyConfiguration;
 import io.shardingjdbc.core.api.config.strategy.StandardShardingStrategyConfiguration;
+import io.shardingjdbc.core.yaml.sharding.strategy.YamlComplexShardingStrategyConfiguration;
+import io.shardingjdbc.core.yaml.sharding.strategy.YamlHintShardingStrategyConfiguration;
+import io.shardingjdbc.core.yaml.sharding.strategy.YamlInlineShardingStrategyConfiguration;
+import io.shardingjdbc.core.yaml.sharding.strategy.YamlNoneShardingStrategyConfiguration;
+import io.shardingjdbc.core.yaml.sharding.strategy.YamlStandardShardingStrategyConfiguration;
 import lombok.Getter;
 import lombok.Setter;
 
@@ -17,42 +22,47 @@ import lombok.Setter;
  */
 @Getter
 @Setter
-public class YamlShardingStrategyConfig {
+public class YamlShardingStrategyConfiguration {
     
-    private ComplexShardingStrategyConfiguration complex;
+    private YamlStandardShardingStrategyConfiguration standard;
     
-    private HintShardingStrategyConfiguration hint;
+    private YamlComplexShardingStrategyConfiguration complex;
     
-    private InlineShardingStrategyConfiguration inline;
+    private YamlHintShardingStrategyConfiguration hint;
     
-    private NoneShardingStrategyConfiguration none;
+    private YamlInlineShardingStrategyConfiguration inline;
     
-    private StandardShardingStrategyConfiguration standard;
+    private YamlNoneShardingStrategyConfiguration none;
     
-    public ShardingStrategyConfiguration getShardingStrategy() {
+    /**
+     * Build sharding strategy configuration.
+     * 
+     * @return sharding strategy configuration
+     */
+    public ShardingStrategyConfiguration build() {
         int shardingStrategyConfigCount = 0;
-        ShardingStrategyConfiguration shardingStrategy = null;
+        ShardingStrategyConfiguration result = null;
+        if (null != standard) {
+            shardingStrategyConfigCount++;
+            result = new StandardShardingStrategyConfiguration(standard.getShardingColumn(), standard.getPreciseAlgorithmClassName(), standard.getRangeAlgorithmClassName());
+        }
         if (null != complex) {
             shardingStrategyConfigCount++;
-            shardingStrategy = complex;
+            result = new ComplexShardingStrategyConfiguration(complex.getShardingColumns(), complex.getAlgorithmClassName());
         }
         if (null != inline) {
             shardingStrategyConfigCount++;
-            shardingStrategy = inline;
+            result = new InlineShardingStrategyConfiguration(inline.getShardingColumn(), inline.getAlgorithmInlineExpression());
         }
         if (null != hint) {
             shardingStrategyConfigCount++;
-            shardingStrategy = hint;
-        }
-        if (null != standard) {
-            shardingStrategyConfigCount++;
-            shardingStrategy = standard;
+            result = new HintShardingStrategyConfiguration(hint.getAlgorithmClassName());
         }
         if (null != none) {
             shardingStrategyConfigCount++;
-            shardingStrategy = none;
+            result = new NoneShardingStrategyConfiguration();
         }
         Preconditions.checkArgument(shardingStrategyConfigCount <= 1, "Only allowed 0 or 1 sharding strategy configuration.");
-        return shardingStrategy;
+        return result;
     }
 }

sharding-jdbc-core/src/main/java/io/shardingjdbc/core/yaml/sharding/YamlTableRuleConfig.java → sharding-jdbc-core/src/main/java/io/shardingjdbc/core/yaml/sharding/YamlTableRuleConfiguration.java

@@ -12,7 +12,7 @@ import lombok.Setter;
  */
 @Getter
 @Setter
-public class YamlTableRuleConfig {
+public class YamlTableRuleConfiguration {
     
     private String logicTable;
     
@@ -20,30 +20,30 @@ public class YamlTableRuleConfig {
     
     private String dataSourceNames;
     
-    private YamlShardingStrategyConfig databaseStrategy;
+    private YamlShardingStrategyConfiguration databaseStrategy;
     
-    private YamlShardingStrategyConfig tableStrategy;
+    private YamlShardingStrategyConfiguration tableStrategy;
     
     private String keyGeneratorColumnName;
     
     private String keyGeneratorClass;
     
     /**
-     * Build table rule.
+     * Build table rule configuration.
      *
-     * @return table rule
+     * @return table rule configuration
      */
-    public TableRuleConfiguration getTableRuleConfig() {
+    public TableRuleConfiguration build() {
         Preconditions.checkNotNull(logicTable, "Logic table cannot be null.");
         TableRuleConfiguration tableRuleConfig = new TableRuleConfiguration();
         tableRuleConfig.setLogicTable(logicTable);
         tableRuleConfig.setActualTables(actualTables);
         tableRuleConfig.setLogicTable(logicTable);
         if (null != databaseStrategy) {
-            tableRuleConfig.setDatabaseShardingStrategyConfig(databaseStrategy.getShardingStrategy());
+            tableRuleConfig.setDatabaseShardingStrategyConfig(databaseStrategy.build());
         }
         if (null != tableStrategy) {
-            tableRuleConfig.setTableShardingStrategyConfig(tableStrategy.getShardingStrategy());
+            tableRuleConfig.setTableShardingStrategyConfig(tableStrategy.build());
         }
         tableRuleConfig.setKeyGeneratorClass(keyGeneratorClass);
         tableRuleConfig.setKeyGeneratorColumnName(keyGeneratorColumnName);

sharding-jdbc-core/src/main/java/io/shardingjdbc/core/yaml/sharding/strategy/YamlComplexShardingStrategyConfiguration.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 io.shardingjdbc.core.yaml.sharding.strategy;
+
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * Complex sharding strategy configuration for yaml.
+ * 
+ * @author zhangliang
+ */
+@Getter
+@Setter
+public final class YamlComplexShardingStrategyConfiguration implements YamlShardingStrategyConfiguration {
+    
+    private String shardingColumns;
+    
+    private String algorithmClassName;
+}

sharding-jdbc-core/src/main/java/io/shardingjdbc/core/yaml/sharding/strategy/YamlHintShardingStrategyConfiguration.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 io.shardingjdbc.core.yaml.sharding.strategy;
+
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * Hint sharding strategy configuration for yaml.
+ * 
+ * @author zhangliang
+ */
+@Getter
+@Setter
+public final class YamlHintShardingStrategyConfiguration implements YamlShardingStrategyConfiguration {
+    
+    private String algorithmClassName;
+}

sharding-jdbc-core/src/main/java/io/shardingjdbc/core/yaml/sharding/strategy/YamlInlineShardingStrategyConfiguration.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 io.shardingjdbc.core.yaml.sharding.strategy;
+
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * Inline sharding strategy configuration for yaml.
+ * 
+ * @author zhangliang
+ */
+@Getter
+@Setter
+public final class YamlInlineShardingStrategyConfiguration implements YamlShardingStrategyConfiguration {
+    
+    private String shardingColumn;
+    
+    private String algorithmInlineExpression;
+}

sharding-jdbc-core/src/main/java/io/shardingjdbc/core/yaml/sharding/strategy/YamlNoneShardingStrategyConfiguration.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 io.shardingjdbc.core.yaml.sharding.strategy;
+
+/**
+ * None sharding strategy configuration for yaml.
+ * 
+ * @author zhangliang
+ */
+public final class YamlNoneShardingStrategyConfiguration implements YamlShardingStrategyConfiguration {
+}

sharding-jdbc-core/src/main/java/io/shardingjdbc/core/yaml/sharding/strategy/YamlShardingStrategyConfiguration.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 io.shardingjdbc.core.yaml.sharding.strategy;
+
+/**
+ * Sharding strategy configuration for yaml.
+ * 
+ * @author zhangliang
+ */
+public interface YamlShardingStrategyConfiguration {
+}

sharding-jdbc-core/src/main/java/io/shardingjdbc/core/yaml/sharding/YamlShardingConfig.java → sharding-jdbc-core/src/main/java/io/shardingjdbc/core/yaml/sharding/strategy/YamlStandardShardingStrategyConfiguration.java

@@ -15,43 +15,23 @@
  * </p>
  */
 
-package io.shardingjdbc.core.yaml.sharding;
+package io.shardingjdbc.core.yaml.sharding.strategy;
 
-import io.shardingjdbc.core.yaml.masterslave.YamlMasterSlaveConfig;
 import lombok.Getter;
 import lombok.Setter;
 
-import javax.sql.DataSource;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Properties;
-
 /**
- * Sharding configuration for yaml.
- *
- * @author caohao
+ * Standard strategy configuration for yaml.
+ * 
+ * @author zhangliang
  */
 @Getter
 @Setter
-public class YamlShardingConfig {
-    
-    private Map<String, DataSource> dataSources = new HashMap<>();
-    
-    private String defaultDataSourceName;
-    
-    private Map<String, YamlTableRuleConfig> tables = new HashMap<>();
-    
-    private List<String> bindingTables = new ArrayList<>();
-    
-    private YamlShardingStrategyConfig defaultDatabaseStrategy;
-    
-    private YamlShardingStrategyConfig defaultTableStrategy;
+public final class YamlStandardShardingStrategyConfiguration implements YamlShardingStrategyConfiguration {
     
-    private String defaultKeyGeneratorClass;
+    private String shardingColumn;
     
-    private Map<String, YamlMasterSlaveConfig> masterSlaveRules = new HashMap<>();
+    private String preciseAlgorithmClassName;
     
-    private Properties props = new Properties();
+    private String rangeAlgorithmClassName;
 }

sharding-jdbc-core/src/test/java/io/shardingjdbc/core/common/base/AbstractShardingJDBCDatabaseAndTableTest.java

@@ -69,16 +69,10 @@ public abstract class AbstractShardingJDBCDatabaseAndTableTest extends AbstractS
             configTableRuleConfig.setLogicTable("t_config");
             shardingRuleConfig.getTableRuleConfigs().add(configTableRuleConfig);
             shardingRuleConfig.getBindingTableGroups().add("t_order, t_order_item");
-            StandardShardingStrategyConfiguration databaseShardingStrategyConfig = new StandardShardingStrategyConfiguration();
-            databaseShardingStrategyConfig.setShardingColumn("user_id");
-            databaseShardingStrategyConfig.setPreciseAlgorithmClassName(PreciseOrderShardingAlgorithm.class.getName());
-            databaseShardingStrategyConfig.setRangeAlgorithmClassName(RangeOrderShardingAlgorithm.class.getName());
-            shardingRuleConfig.setDefaultDatabaseShardingStrategyConfig(databaseShardingStrategyConfig);
-            StandardShardingStrategyConfiguration tableShardingStrategyConfig = new StandardShardingStrategyConfiguration();
-            tableShardingStrategyConfig.setShardingColumn("order_id");
-            tableShardingStrategyConfig.setPreciseAlgorithmClassName(PreciseOrderShardingAlgorithm.class.getName());
-            tableShardingStrategyConfig.setRangeAlgorithmClassName(RangeOrderShardingAlgorithm.class.getName());
-            shardingRuleConfig.setDefaultTableShardingStrategyConfig(tableShardingStrategyConfig);
+            shardingRuleConfig.setDefaultDatabaseShardingStrategyConfig(
+                    new StandardShardingStrategyConfiguration("user_id", PreciseOrderShardingAlgorithm.class.getName(), RangeOrderShardingAlgorithm.class.getName()));
+            shardingRuleConfig.setDefaultTableShardingStrategyConfig(
+                    new StandardShardingStrategyConfiguration("order_id", PreciseOrderShardingAlgorithm.class.getName(), RangeOrderShardingAlgorithm.class.getName()));
             ShardingRule shardingRule = shardingRuleConfig.build(each.getValue());
             shardingDataSources.put(each.getKey(), new ShardingDataSource(shardingRule));
         }

sharding-jdbc-core/src/test/java/io/shardingjdbc/core/integrate/type/sharding/NullableShardingTableOnlyTest.java

@@ -90,10 +90,7 @@ public class NullableShardingTableOnlyTest extends AbstractSQLAssertTest {
             TableRuleConfiguration tableRuleConfig = new TableRuleConfiguration();
             tableRuleConfig.setLogicTable("t_order");
             shardingRuleConfig.getTableRuleConfigs().add(tableRuleConfig);
-            ComplexShardingStrategyConfiguration databaseShardingStrategyConfig = new ComplexShardingStrategyConfiguration();
-            databaseShardingStrategyConfig.setShardingColumns("user_id");
-            databaseShardingStrategyConfig.setAlgorithmClassName(ComplexKeysModuloDatabaseShardingAlgorithm.class.getName());
-            shardingRuleConfig.setDefaultDatabaseShardingStrategyConfig(databaseShardingStrategyConfig);
+            shardingRuleConfig.setDefaultDatabaseShardingStrategyConfig(new ComplexShardingStrategyConfiguration("user_id", ComplexKeysModuloDatabaseShardingAlgorithm.class.getName()));
             ShardingRule shardingRule = shardingRuleConfig.build(each.getValue());
             shardingDataSources.put(each.getKey(), new ShardingDataSource(shardingRule));
         }

sharding-jdbc-core/src/test/java/io/shardingjdbc/core/integrate/type/sharding/ShardingDatabaseAndTableTest.java

@@ -90,16 +90,10 @@ public class ShardingDatabaseAndTableTest extends AbstractSQLAssertTest {
             configTableRuleConfig.setLogicTable("t_config");
             shardingRuleConfig.getTableRuleConfigs().add(configTableRuleConfig);
             shardingRuleConfig.getBindingTableGroups().add("t_order, t_order_item");
-            StandardShardingStrategyConfiguration databaseShardingStrategyConfig = new StandardShardingStrategyConfiguration();
-            databaseShardingStrategyConfig.setShardingColumn("user_id");
-            databaseShardingStrategyConfig.setPreciseAlgorithmClassName(PreciseModuloDatabaseShardingAlgorithm.class.getName());
-            databaseShardingStrategyConfig.setRangeAlgorithmClassName(RangeModuloDatabaseShardingAlgorithm.class.getName());
-            shardingRuleConfig.setDefaultDatabaseShardingStrategyConfig(databaseShardingStrategyConfig);
-            StandardShardingStrategyConfiguration tableShardingStrategyConfig = new StandardShardingStrategyConfiguration();
-            tableShardingStrategyConfig.setShardingColumn("order_id");
-            tableShardingStrategyConfig.setPreciseAlgorithmClassName(PreciseModuloTableShardingAlgorithm.class.getName());
-            tableShardingStrategyConfig.setRangeAlgorithmClassName(RangeModuloTableShardingAlgorithm.class.getName());
-            shardingRuleConfig.setDefaultTableShardingStrategyConfig(tableShardingStrategyConfig);
+            shardingRuleConfig.setDefaultDatabaseShardingStrategyConfig(
+                    new StandardShardingStrategyConfiguration("user_id", PreciseModuloDatabaseShardingAlgorithm.class.getName(), RangeModuloDatabaseShardingAlgorithm.class.getName()));
+            shardingRuleConfig.setDefaultTableShardingStrategyConfig(
+                    new StandardShardingStrategyConfiguration("order_id", PreciseModuloTableShardingAlgorithm.class.getName(), RangeModuloTableShardingAlgorithm.class.getName()));
             shardingDataSources.put(each.getKey(), new ShardingDataSource(shardingRuleConfig.build(each.getValue())));
         }
         return shardingDataSources;

sharding-jdbc-core/src/test/java/io/shardingjdbc/core/integrate/type/sharding/ShardingDatabaseOnlyTest.java

@@ -85,10 +85,7 @@ public class ShardingDatabaseOnlyTest extends AbstractSQLAssertTest {
             orderItemTableRuleConfig.setLogicTable("t_order_item");
             shardingRuleConfig.getTableRuleConfigs().add(orderItemTableRuleConfig);
             shardingRuleConfig.getBindingTableGroups().add("t_order, t_order_item");
-            ComplexShardingStrategyConfiguration databaseShardingStrategyConfig = new ComplexShardingStrategyConfiguration();
-            databaseShardingStrategyConfig.setShardingColumns("user_id");
-            databaseShardingStrategyConfig.setAlgorithmClassName(ComplexKeysModuloDatabaseShardingAlgorithm.class.getName());
-            shardingRuleConfig.setDefaultDatabaseShardingStrategyConfig(databaseShardingStrategyConfig);
+            shardingRuleConfig.setDefaultDatabaseShardingStrategyConfig(new ComplexShardingStrategyConfiguration("user_id", ComplexKeysModuloDatabaseShardingAlgorithm.class.getName()));
             shardingRuleConfig.setDefaultTableShardingStrategyConfig(new NoneShardingStrategyConfiguration());
             shardingDataSources.put(each.getKey(), new ShardingDataSource(shardingRuleConfig.build(each.getValue())));
         }

sharding-jdbc-core/src/test/java/io/shardingjdbc/core/integrate/type/sharding/ShardingMasterSlaveTest.java

@@ -102,16 +102,10 @@ public class ShardingMasterSlaveTest extends AbstractSQLAssertTest {
             configTableRuleConfig.setLogicTable("t_config");
             configTableRuleConfig.setActualTables("t_config");
             shardingRuleConfig.getTableRuleConfigs().add(configTableRuleConfig);
-            StandardShardingStrategyConfiguration databaseShardingStrategy = new StandardShardingStrategyConfiguration();
-            databaseShardingStrategy.setShardingColumn("t_order_item");
-            databaseShardingStrategy.setPreciseAlgorithmClassName(PreciseModuloDatabaseShardingAlgorithm.class.getName());
-            databaseShardingStrategy.setRangeAlgorithmClassName(RangeModuloDatabaseShardingAlgorithm.class.getName());
-            shardingRuleConfig.setDefaultTableShardingStrategyConfig(databaseShardingStrategy);
-            StandardShardingStrategyConfiguration tableShardingStrategy = new StandardShardingStrategyConfiguration();
-            tableShardingStrategy.setShardingColumn("user_id");
-            tableShardingStrategy.setPreciseAlgorithmClassName(PreciseModuloDatabaseShardingAlgorithm.class.getName());
-            tableShardingStrategy.setRangeAlgorithmClassName(RangeModuloDatabaseShardingAlgorithm.class.getName());
-            shardingRuleConfig.setDefaultDatabaseShardingStrategyConfig(tableShardingStrategy);
+            shardingRuleConfig.setDefaultTableShardingStrategyConfig(
+                    new StandardShardingStrategyConfiguration("t_order_item", PreciseModuloDatabaseShardingAlgorithm.class.getName(), RangeModuloDatabaseShardingAlgorithm.class.getName()));
+            shardingRuleConfig.setDefaultDatabaseShardingStrategyConfig(
+                    new StandardShardingStrategyConfiguration("user_id", PreciseModuloDatabaseShardingAlgorithm.class.getName(), RangeModuloDatabaseShardingAlgorithm.class.getName()));
             shardingDataSources.put(each.getKey(), new ShardingDataSource(shardingRuleConfig.build(getMasterSlaveDataSourceMap(each))));
         }
         return shardingDataSources;

sharding-jdbc-core/src/test/java/io/shardingjdbc/core/integrate/type/sharding/ShardingTableOnlyTest.java

@@ -78,11 +78,8 @@ public class ShardingTableOnlyTest extends AbstractSQLAssertTest {
             shardingRuleConfig.getTableRuleConfigs().add(orderItemTableRuleConfig);
             shardingRuleConfig.getBindingTableGroups().add("t_order, t_order_item");
             shardingRuleConfig.setDefaultDatabaseShardingStrategyConfig(new NoneShardingStrategyConfiguration());
-            StandardShardingStrategyConfiguration tableShardingStrategyConfig = new StandardShardingStrategyConfiguration();
-            tableShardingStrategyConfig.setShardingColumn("order_id");
-            tableShardingStrategyConfig.setPreciseAlgorithmClassName(PreciseModuloTableShardingAlgorithm.class.getName());
-            tableShardingStrategyConfig.setRangeAlgorithmClassName(RangeModuloTableShardingAlgorithm.class.getName());
-            shardingRuleConfig.setDefaultTableShardingStrategyConfig(tableShardingStrategyConfig);
+            shardingRuleConfig.setDefaultTableShardingStrategyConfig(
+                    new StandardShardingStrategyConfiguration("order_id", PreciseModuloTableShardingAlgorithm.class.getName(), RangeModuloTableShardingAlgorithm.class.getName()));
             shardingDataSources.put(each.getKey(), new ShardingDataSource(shardingRuleConfig.build(each.getValue())));
         }
         return shardingDataSources;

sharding-jdbc-core/src/test/java/io/shardingjdbc/core/integrate/type/sharding/hint/base/AbstractRoutingDatabaseOnlyWithHintTest.java

@@ -32,9 +32,7 @@ public abstract class AbstractRoutingDatabaseOnlyWithHintTest extends AbstractHi
     @Override
     protected ShardingRule getShardingRule(final Map.Entry<DatabaseType, Map<String, DataSource>> dataSourceEntry) throws SQLException {
         ShardingRuleConfiguration shardingRuleConfig = new ShardingRuleConfiguration();
-        HintShardingStrategyConfiguration shardingStrategyConfig = new HintShardingStrategyConfiguration();
-        shardingStrategyConfig.setAlgorithmClassName(HintModuloDatabaseShardingAlgorithm.class.getName());
-        shardingRuleConfig.setDefaultDatabaseShardingStrategyConfig(shardingStrategyConfig);
+        shardingRuleConfig.setDefaultDatabaseShardingStrategyConfig(new HintShardingStrategyConfiguration(HintModuloDatabaseShardingAlgorithm.class.getName()));
         return shardingRuleConfig.build(dataSourceEntry.getValue());
     }
 }

sharding-jdbc-core/src/test/java/io/shardingjdbc/core/integrate/type/sharding/hint/base/AbstractShardingDatabaseOnlyWithHintTest.java

@@ -41,10 +41,7 @@ public abstract class AbstractShardingDatabaseOnlyWithHintTest extends AbstractH
         orderItemTableRuleConfig.setLogicTable("t_order_item");
         shardingRuleConfig.getTableRuleConfigs().add(orderItemTableRuleConfig);
         shardingRuleConfig.getBindingTableGroups().add("t_order, t_order_item");
-        ComplexShardingStrategyConfiguration databaseShardingStrategyConfig = new ComplexShardingStrategyConfiguration();
-        databaseShardingStrategyConfig.setShardingColumns("user_id");
-        databaseShardingStrategyConfig.setAlgorithmClassName(ComplexKeysModuloDatabaseShardingAlgorithm.class.getName());
-        shardingRuleConfig.setDefaultDatabaseShardingStrategyConfig(databaseShardingStrategyConfig);
+        shardingRuleConfig.setDefaultDatabaseShardingStrategyConfig(new ComplexShardingStrategyConfiguration("user_id", ComplexKeysModuloDatabaseShardingAlgorithm.class.getName()));
         shardingRuleConfig.setDefaultTableShardingStrategyConfig(new NoneShardingStrategyConfiguration());
         return shardingRuleConfig.build(dataSourceEntry.getValue());
     }

sharding-jdbc-core/src/test/java/io/shardingjdbc/core/parsing/SQLParsingEngineTest.java

@@ -70,18 +70,12 @@ public final class SQLParsingEngineTest extends AbstractBaseParseSQLTest {
         orderTableRuleConfig.setLogicTable("t_order");
         orderTableRuleConfig.setActualTables("t_order");
         orderTableRuleConfig.setDataSourceNames("db0, db1");
-        ComplexShardingStrategyConfiguration orderShardingStrategyConfig = new ComplexShardingStrategyConfiguration();
-        orderShardingStrategyConfig.setShardingColumns("user_id, order_id");
-        orderShardingStrategyConfig.setAlgorithmClassName(TestComplexKeysShardingAlgorithm.class.getName());
-        orderTableRuleConfig.setTableShardingStrategyConfig(orderShardingStrategyConfig);
+        orderTableRuleConfig.setTableShardingStrategyConfig(new ComplexShardingStrategyConfiguration("user_id, order_id", TestComplexKeysShardingAlgorithm.class.getName()));
         TableRuleConfiguration orderItemTableRuleConfig = new TableRuleConfiguration();
         orderItemTableRuleConfig.setLogicTable("t_order_item");
         orderItemTableRuleConfig.setActualTables("t_order_item");
         orderItemTableRuleConfig.setDataSourceNames("db0, db1");
-        ComplexShardingStrategyConfiguration orderItemShardingStrategyConfig = new ComplexShardingStrategyConfiguration();
-        orderItemShardingStrategyConfig.setShardingColumns("user_id, order_id, item_id");
-        orderItemShardingStrategyConfig.setAlgorithmClassName(TestComplexKeysShardingAlgorithm.class.getName());
-        orderItemTableRuleConfig.setTableShardingStrategyConfig(orderItemShardingStrategyConfig);
+        orderItemTableRuleConfig.setTableShardingStrategyConfig(new ComplexShardingStrategyConfiguration("user_id, order_id, item_id", TestComplexKeysShardingAlgorithm.class.getName()));
         return new ShardingRuleMockBuilder().addTableRuleConfig(orderTableRuleConfig).addTableRuleConfig(orderItemTableRuleConfig)
                 .addShardingColumns("user_id").addShardingColumns("order_id").addShardingColumns("item_id").addGenerateKeyColumn("t_order_item", "item_id").build();
     }

sharding-jdbc-core/src/test/java/io/shardingjdbc/core/parsing/parser/sql/AbstractStatementParserTest.java

@@ -49,10 +49,8 @@ public abstract class AbstractStatementParserTest {
         TableRuleConfiguration tableRuleConfig = new TableRuleConfiguration();
         tableRuleConfig.setLogicTable("TABLE_XXX");
         tableRuleConfig.setActualTables("table_0, table_1, table_2");
-        ComplexShardingStrategyConfiguration complexShardingStrategyConfig = new ComplexShardingStrategyConfiguration();
-        complexShardingStrategyConfig.setShardingColumns("field1, field2, field3, field4, field5, field6, field7");
-        complexShardingStrategyConfig.setAlgorithmClassName(TestComplexKeysShardingAlgorithm.class.getName());
-        tableRuleConfig.setTableShardingStrategyConfig(complexShardingStrategyConfig);
+        tableRuleConfig.setTableShardingStrategyConfig(
+                new ComplexShardingStrategyConfiguration("field1, field2, field3, field4, field5, field6, field7", TestComplexKeysShardingAlgorithm.class.getName()));
         ShardingRuleConfiguration shardingRuleConfig = new ShardingRuleConfiguration();
         shardingRuleConfig.getTableRuleConfigs().add(tableRuleConfig);
         Map<String, DataSource> dataSourceMap = new HashMap<>(1, 1);

sharding-jdbc-core/src/test/java/io/shardingjdbc/core/parsing/parser/sql/InsertStatementParserTest.java

@@ -111,10 +111,7 @@ public final class InsertStatementParserTest extends AbstractStatementParserTest
         TableRuleConfiguration tableRuleConfig = new TableRuleConfiguration();
         tableRuleConfig.setLogicTable("TABLE_XXX");
         tableRuleConfig.setActualTables("table_${0..2}");
-        ComplexShardingStrategyConfiguration shardingStrategyConfig = new ComplexShardingStrategyConfiguration();
-        shardingStrategyConfig.setShardingColumns("field1");
-        shardingStrategyConfig.setAlgorithmClassName(TestComplexKeysShardingAlgorithm.class.getName());
-        tableRuleConfig.setTableShardingStrategyConfig(shardingStrategyConfig);
+        tableRuleConfig.setTableShardingStrategyConfig(new ComplexShardingStrategyConfiguration("field1", TestComplexKeysShardingAlgorithm.class.getName()));
         tableRuleConfig.setKeyGeneratorColumnName("field2");
         shardingRuleConfig.getTableRuleConfigs().add(tableRuleConfig);
         shardingRuleConfig.setDefaultKeyGeneratorClass(IncrementKeyGenerator.class.getName());

sharding-jdbc-core/src/test/java/io/shardingjdbc/core/routing/DatabaseTest.java

@@ -48,9 +48,7 @@ public class DatabaseTest {
     @Before
     public void setRouteRuleContext() throws SQLException {
         ShardingRuleConfiguration shardingRuleConfig = new ShardingRuleConfiguration();
-        HintShardingStrategyConfiguration databaseShardingStrategyConfig = new HintShardingStrategyConfiguration();
-        databaseShardingStrategyConfig.setAlgorithmClassName(OrderDatabaseHintShardingAlgorithm.class.getName());
-        shardingRuleConfig.setDefaultDatabaseShardingStrategyConfig(databaseShardingStrategyConfig);
+        shardingRuleConfig.setDefaultDatabaseShardingStrategyConfig(new HintShardingStrategyConfiguration(OrderDatabaseHintShardingAlgorithm.class.getName()));
         Map<String, DataSource> dataSourceMap = new HashMap<>();
         dataSourceMap.put("ds_0", null);
         dataSourceMap.put("ds_1", null);

sharding-jdbc-core/src/test/java/io/shardingjdbc/core/rule/ShardingRuleTest.java

@@ -231,10 +231,7 @@ public final class ShardingRuleTest {
     public void assertIsShardingColumnForDefaultDatabaseShardingStrategy() throws SQLException {
         ShardingRuleConfiguration shardingRuleConfig = new ShardingRuleConfiguration();
         shardingRuleConfig.getTableRuleConfigs().add(createTableRuleConfigWithAllStrategies());
-        StandardShardingStrategyConfiguration databaseShardingStrategyConfig = new StandardShardingStrategyConfiguration();
-        databaseShardingStrategyConfig.setShardingColumn("column");
-        databaseShardingStrategyConfig.setPreciseAlgorithmClassName(TestPreciseShardingAlgorithm.class.getName());
-        shardingRuleConfig.setDefaultDatabaseShardingStrategyConfig(databaseShardingStrategyConfig);
+        shardingRuleConfig.setDefaultDatabaseShardingStrategyConfig(new StandardShardingStrategyConfiguration("column", TestPreciseShardingAlgorithm.class.getName()));
         assertTrue(shardingRuleConfig.build(createDataSourceMap()).isShardingColumn(new Column("column", "")));
     }
     
@@ -242,10 +239,7 @@ public final class ShardingRuleTest {
     public void assertIsShardingColumnForDefaultTableShardingStrategy() throws SQLException {
         ShardingRuleConfiguration shardingRuleConfig = new ShardingRuleConfiguration();
         shardingRuleConfig.getTableRuleConfigs().add(createTableRuleConfigWithAllStrategies());
-        StandardShardingStrategyConfiguration tableShardingStrategyConfig = new StandardShardingStrategyConfiguration();
-        tableShardingStrategyConfig.setShardingColumn("column");
-        tableShardingStrategyConfig.setPreciseAlgorithmClassName(TestPreciseShardingAlgorithm.class.getName());
-        shardingRuleConfig.setDefaultTableShardingStrategyConfig(tableShardingStrategyConfig);
+        shardingRuleConfig.setDefaultTableShardingStrategyConfig(new StandardShardingStrategyConfiguration("column", TestPreciseShardingAlgorithm.class.getName()));
         assertTrue(shardingRuleConfig.build(createDataSourceMap()).isShardingColumn(new Column("column", "")));
     }
     
@@ -321,10 +315,7 @@ public final class ShardingRuleTest {
         TableRuleConfiguration result = new TableRuleConfiguration();
         result.setLogicTable("logicTable");
         result.setActualTables("table_0, table_1, table_2");
-        StandardShardingStrategyConfiguration databaseShardingStrategyConfig = new StandardShardingStrategyConfiguration();
-        databaseShardingStrategyConfig.setShardingColumn("column");
-        databaseShardingStrategyConfig.setPreciseAlgorithmClassName(TestPreciseShardingAlgorithm.class.getName());
-        result.setDatabaseShardingStrategyConfig(databaseShardingStrategyConfig);
+        result.setDatabaseShardingStrategyConfig(new StandardShardingStrategyConfiguration("column", TestPreciseShardingAlgorithm.class.getName()));
         result.setTableShardingStrategyConfig(new NoneShardingStrategyConfiguration());
         return result;
     }
@@ -333,10 +324,7 @@ public final class ShardingRuleTest {
         TableRuleConfiguration result = new TableRuleConfiguration();
         result.setLogicTable("logicTable");
         result.setActualTables("table_0, table_1, table_2");
-        StandardShardingStrategyConfiguration tableShardingStrategyConfig = new StandardShardingStrategyConfiguration();
-        tableShardingStrategyConfig.setShardingColumn("column");
-        tableShardingStrategyConfig.setPreciseAlgorithmClassName(TestPreciseShardingAlgorithm.class.getName());
-        result.setTableShardingStrategyConfig(tableShardingStrategyConfig);
+        result.setTableShardingStrategyConfig(new StandardShardingStrategyConfiguration("column", TestPreciseShardingAlgorithm.class.getName()));
         return result;
     }
 }

sharding-jdbc-orchestration/src/main/java/io/shardingjdbc/orchestration/json/ShardingStrategyConfigurationGsonTypeAdapter.java

@@ -83,16 +83,16 @@ public final class ShardingStrategyConfigurationGsonTypeAdapter extends TypeAdap
                                                          final String algorithmClassName, final String preciseAlgorithmClassName, final String rangeAlgorithmClassName,
                                                          final String algorithmInlineExpression) {
         if (type.equals(ShardingStrategyType.STANDARD.name())) {
-            return createStandardStrategy(shardingColumn, preciseAlgorithmClassName, rangeAlgorithmClassName);
+            return new StandardShardingStrategyConfiguration(shardingColumn, preciseAlgorithmClassName, rangeAlgorithmClassName);
         }
         if (type.equals(ShardingStrategyType.COMPLEX.name())) {
-            return createComplexStrategy(shardingColumns, algorithmClassName);
+            return new ComplexShardingStrategyConfiguration(shardingColumns, algorithmClassName);
         }
         if (type.equals(ShardingStrategyType.INLINE.name())) {
-            return createInlineStrategy(shardingColumn, algorithmInlineExpression);
+            return new InlineShardingStrategyConfiguration(shardingColumn, algorithmInlineExpression);
         }
         if (type.equals(ShardingStrategyType.HINT.name())) {
-            return createHintStrategy(algorithmClassName);
+            return new HintShardingStrategyConfiguration(algorithmClassName);
         }
         if (type.equals(ShardingStrategyType.NONE.name())) {
             return new NoneShardingStrategyConfiguration();
@@ -100,34 +100,6 @@ public final class ShardingStrategyConfigurationGsonTypeAdapter extends TypeAdap
         return null;
     }
     
-    private ShardingStrategyConfiguration createStandardStrategy(final String shardingColumn, final String preciseAlgorithmClassName, final String rangeAlgorithmClassName) {
-        StandardShardingStrategyConfiguration result = new StandardShardingStrategyConfiguration();
-        result.setShardingColumn(shardingColumn);
-        result.setPreciseAlgorithmClassName(preciseAlgorithmClassName);
-        result.setRangeAlgorithmClassName(rangeAlgorithmClassName);
-        return result;
-    }
-    
-    private ShardingStrategyConfiguration createComplexStrategy(final String shardingColumns, final String algorithmClassName) {
-        ComplexShardingStrategyConfiguration result = new ComplexShardingStrategyConfiguration();
-        result.setShardingColumns(shardingColumns);
-        result.setAlgorithmClassName(algorithmClassName);
-        return result;
-    }
-    
-    private ShardingStrategyConfiguration createInlineStrategy(final String shardingColumn, final String algorithmInlineExpression) {
-        InlineShardingStrategyConfiguration result = new InlineShardingStrategyConfiguration();
-        result.setShardingColumn(shardingColumn);
-        result.setAlgorithmInlineExpression(algorithmInlineExpression);
-        return result;
-    }
-    
-    private ShardingStrategyConfiguration createHintStrategy(final String algorithmClassName) {
-        HintShardingStrategyConfiguration result = new HintShardingStrategyConfiguration();
-        result.setAlgorithmClassName(algorithmClassName);
-        return result;
-    }
-    
     @Override
     public void write(final JsonWriter out, final ShardingStrategyConfiguration value) throws IOException {
         out.beginObject();

sharding-jdbc-orchestration/src/test/java/io/shardingjdbc/orchestration/json/ShardingRuleConfigurationConverterTest.java

@@ -29,33 +29,25 @@ public final class ShardingRuleConfigurationConverterTest {
     
     @Test
     public void assertToJsonForStandardStrategy() {
-        StandardShardingStrategyConfiguration actual = new StandardShardingStrategyConfiguration();
-        actual.setShardingColumn("order_id");
-        actual.setPreciseAlgorithmClassName("xxx.XXXPreciseAlgorithm");
-        actual.setRangeAlgorithmClassName("xxx.XXXRangeAlgorithm");
+        StandardShardingStrategyConfiguration actual = new StandardShardingStrategyConfiguration("order_id", "xxx.XXXPreciseAlgorithm", "xxx.XXXRangeAlgorithm");
         assertThat(ShardingRuleConfigurationConverter.toJson(getCommonShardingRuleConfig(actual)), is(getJsonForStandardStrategy()));
     }
     
     @Test
     public void assertToJsonForComplexStrategy() {
-        ComplexShardingStrategyConfiguration actual = new ComplexShardingStrategyConfiguration();
-        actual.setShardingColumns("order_id,item_id");
-        actual.setAlgorithmClassName("xxx.XXXAlgorithm");
+        ComplexShardingStrategyConfiguration actual = new ComplexShardingStrategyConfiguration("order_id,item_id", "xxx.XXXAlgorithm");
         assertThat(ShardingRuleConfigurationConverter.toJson(getCommonShardingRuleConfig(actual)), is(getJsonForComplexStrategy()));
     }
     
     @Test
     public void assertToJsonForInlineStrategy() {
-        InlineShardingStrategyConfiguration actual = new InlineShardingStrategyConfiguration();
-        actual.setShardingColumn("order_id");
-        actual.setAlgorithmInlineExpression("order_${user_id % 2}");
+        InlineShardingStrategyConfiguration actual = new InlineShardingStrategyConfiguration("order_id", "order_${user_id % 2}");
         assertThat(ShardingRuleConfigurationConverter.toJson(getCommonShardingRuleConfig(actual)), is(getJsonForInlineStrategy()));
     }
     
     @Test
     public void assertToJsonForHintStrategy() {
-        HintShardingStrategyConfiguration actual = new HintShardingStrategyConfiguration();
-        actual.setAlgorithmClassName("xxx.XXXAlgorithm");
+        HintShardingStrategyConfiguration actual = new HintShardingStrategyConfiguration("xxx.XXXAlgorithm");
         assertThat(ShardingRuleConfigurationConverter.toJson(getCommonShardingRuleConfig(actual)), is(getJsonForHintStrategy()));
     }
     

sharding-jdbc-spring/sharding-jdbc-spring-namespace/src/main/java/io/shardingjdbc/spring/namespace/parser/ShardingJdbcStrategyBeanDefinition.java

@@ -58,29 +58,29 @@ public class ShardingJdbcStrategyBeanDefinition {
     
     private static AbstractBeanDefinition getStandardShardingStrategyConfigBeanDefinition(final Element element) {
         BeanDefinitionBuilder factory = BeanDefinitionBuilder.rootBeanDefinition(StandardShardingStrategyConfiguration.class);
-        factory.addPropertyValue("shardingColumn", element.getAttribute(ShardingJdbcStrategyBeanDefinitionParserTag.SHARDING_COLUMN_ATTRIBUTE));
-        factory.addPropertyValue("preciseAlgorithmClassName", element.getAttribute(ShardingJdbcStrategyBeanDefinitionParserTag.PRECISE_ALGORITHM_CLASS_ATTRIBUTE));
-        factory.addPropertyValue("rangeAlgorithmClassName", element.getAttribute(ShardingJdbcStrategyBeanDefinitionParserTag.RANGE_ALGORITHM_CLASS_ATTRIBUTE));
+        factory.addConstructorArgValue(element.getAttribute(ShardingJdbcStrategyBeanDefinitionParserTag.SHARDING_COLUMN_ATTRIBUTE));
+        factory.addConstructorArgValue(element.getAttribute(ShardingJdbcStrategyBeanDefinitionParserTag.PRECISE_ALGORITHM_CLASS_ATTRIBUTE));
+        factory.addConstructorArgValue(element.getAttribute(ShardingJdbcStrategyBeanDefinitionParserTag.RANGE_ALGORITHM_CLASS_ATTRIBUTE));
         return factory.getBeanDefinition();
     }
     
     private static AbstractBeanDefinition getComplexShardingStrategyConfigBeanDefinition(final Element element) {
         BeanDefinitionBuilder factory = BeanDefinitionBuilder.rootBeanDefinition(ComplexShardingStrategyConfiguration.class);
-        factory.addPropertyValue("shardingColumns", element.getAttribute(ShardingJdbcStrategyBeanDefinitionParserTag.SHARDING_COLUMNS_ATTRIBUTE));
-        factory.addPropertyValue("algorithmClassName", element.getAttribute(ShardingJdbcStrategyBeanDefinitionParserTag.ALGORITHM_CLASS_ATTRIBUTE));
+        factory.addConstructorArgValue(element.getAttribute(ShardingJdbcStrategyBeanDefinitionParserTag.SHARDING_COLUMNS_ATTRIBUTE));
+        factory.addConstructorArgValue(element.getAttribute(ShardingJdbcStrategyBeanDefinitionParserTag.ALGORITHM_CLASS_ATTRIBUTE));
         return factory.getBeanDefinition();
     }
     
     private static AbstractBeanDefinition getInlineShardingStrategyConfigBeanDefinition(final Element element) {
         BeanDefinitionBuilder factory = BeanDefinitionBuilder.rootBeanDefinition(InlineShardingStrategyConfiguration.class);
-        factory.addPropertyValue("shardingColumn", element.getAttribute(ShardingJdbcStrategyBeanDefinitionParserTag.SHARDING_COLUMN_ATTRIBUTE));
-        factory.addPropertyValue("algorithmInlineExpression", element.getAttribute(ShardingJdbcStrategyBeanDefinitionParserTag.ALGORITHM_EXPRESSION_ATTRIBUTE));
+        factory.addConstructorArgValue(element.getAttribute(ShardingJdbcStrategyBeanDefinitionParserTag.SHARDING_COLUMN_ATTRIBUTE));
+        factory.addConstructorArgValue(element.getAttribute(ShardingJdbcStrategyBeanDefinitionParserTag.ALGORITHM_EXPRESSION_ATTRIBUTE));
         return factory.getBeanDefinition();
     }
     
     private static AbstractBeanDefinition getHintShardingStrategyConfigBeanDefinition(final Element element) {
         BeanDefinitionBuilder factory = BeanDefinitionBuilder.rootBeanDefinition(HintShardingStrategyConfiguration.class);
-        factory.addPropertyValue("algorithmClassName", element.getAttribute(ShardingJdbcStrategyBeanDefinitionParserTag.ALGORITHM_CLASS_ATTRIBUTE));
+        factory.addConstructorArgValue(element.getAttribute(ShardingJdbcStrategyBeanDefinitionParserTag.ALGORITHM_CLASS_ATTRIBUTE));
         return factory.getBeanDefinition();
     }