For #673: remove build() from MasterSlaveRuleConfiguration

sharding-core/src/main/java/io/shardingjdbc/core/api/config/MasterSlaveRuleConfiguration.java

@@ -17,12 +17,7 @@
 
 package io.shardingjdbc.core.api.config;
 
-import com.google.common.base.Preconditions;
-import com.google.common.base.Strings;
 import io.shardingjdbc.core.api.algorithm.masterslave.MasterSlaveLoadBalanceAlgorithm;
-import io.shardingjdbc.core.api.algorithm.masterslave.MasterSlaveLoadBalanceAlgorithmType;
-import io.shardingjdbc.core.exception.ShardingConfigurationException;
-import io.shardingjdbc.core.rule.MasterSlaveRule;
 import lombok.Getter;
 import lombok.Setter;
 
@@ -44,39 +39,5 @@ public class MasterSlaveRuleConfiguration {
     
     private Collection<String> slaveDataSourceNames = new LinkedList<>();
     
-    private MasterSlaveLoadBalanceAlgorithmType loadBalanceAlgorithmType;
-    
-    private String loadBalanceAlgorithmClassName;
-    
-    /**
-     * Build master-slave rule.
-     *
-     * @return master-slave rule
-     */
-    public MasterSlaveRule build() {
-        Preconditions.checkNotNull(name, "name cannot be null.");
-        Preconditions.checkNotNull(masterDataSourceName, "masterDataSourceName cannot be null.");
-        Preconditions.checkNotNull(slaveDataSourceNames, "slaveDataSourceNames cannot be null.");
-        Preconditions.checkArgument(!slaveDataSourceNames.isEmpty(), "slaveDataSourceNames cannot be empty.");
-        return new MasterSlaveRule(name, masterDataSourceName, slaveDataSourceNames, getLoadBalanceAlgorithm());
-    }
-    
-    private MasterSlaveLoadBalanceAlgorithm getLoadBalanceAlgorithm() {
-        if (null == loadBalanceAlgorithmType) {
-            return Strings.isNullOrEmpty(loadBalanceAlgorithmClassName) ? null : newInstance(loadBalanceAlgorithmClassName);
-        }
-        return loadBalanceAlgorithmType.getAlgorithm();
-    }
-    
-    private MasterSlaveLoadBalanceAlgorithm newInstance(final String masterSlaveLoadBalanceAlgorithmClassName) {
-        try {
-            Class<?> result = Class.forName(masterSlaveLoadBalanceAlgorithmClassName);
-            if (!MasterSlaveLoadBalanceAlgorithm.class.isAssignableFrom(result)) {
-                throw new ShardingConfigurationException("Class %s should be implement %s", masterSlaveLoadBalanceAlgorithmClassName, MasterSlaveLoadBalanceAlgorithm.class.getName());
-            }
-            return (MasterSlaveLoadBalanceAlgorithm) result.newInstance();
-        } catch (final ReflectiveOperationException ex) {
-            throw new ShardingConfigurationException("Class %s should have public privilege and no argument constructor", masterSlaveLoadBalanceAlgorithmClassName);
-        }
-    }
+    private MasterSlaveLoadBalanceAlgorithm loadBalanceAlgorithm;
 }

sharding-core/src/main/java/io/shardingjdbc/core/exception/ShardingConfigurationException.java

@@ -35,4 +35,13 @@ public final class ShardingConfigurationException extends RuntimeException {
     public ShardingConfigurationException(final String errorMessage, final Object... args) {
         super(String.format(errorMessage, args));
     }
+    
+    /**
+     * Constructs an exception with cause exception. 
+     *
+     * @param cause cause exception
+     */
+    public ShardingConfigurationException(final Exception cause) {
+        super(cause);
+    }
 }

sharding-core/src/main/java/io/shardingjdbc/core/rule/MasterSlaveRule.java

@@ -20,6 +20,7 @@ package io.shardingjdbc.core.rule;
 import com.google.common.base.Preconditions;
 import io.shardingjdbc.core.api.algorithm.masterslave.MasterSlaveLoadBalanceAlgorithm;
 import io.shardingjdbc.core.api.algorithm.masterslave.MasterSlaveLoadBalanceAlgorithmType;
+import io.shardingjdbc.core.api.config.MasterSlaveRuleConfiguration;
 import lombok.Getter;
 
 import java.util.Collection;
@@ -38,20 +39,16 @@ public final class MasterSlaveRule {
     
     private final Collection<String> slaveDataSourceNames;
     
-    private final MasterSlaveLoadBalanceAlgorithm strategy;
+    private final MasterSlaveLoadBalanceAlgorithm loadBalanceAlgorithm;
     
-    public MasterSlaveRule(final String name, final String masterDataSourceName, final Collection<String> slaveDataSourceNames) {
-        this(name, masterDataSourceName, slaveDataSourceNames, null);
-    }
-    
-    public MasterSlaveRule(final String name, final String masterDataSourceName, final Collection<String> slaveDataSourceNames, final MasterSlaveLoadBalanceAlgorithm strategy) {
+    public MasterSlaveRule(final MasterSlaveRuleConfiguration config) {
+        this.name = config.getName();
+        this.masterDataSourceName = config.getMasterDataSourceName();
+        this.slaveDataSourceNames = config.getSlaveDataSourceNames();
+        this.loadBalanceAlgorithm = null == config.getLoadBalanceAlgorithm() ? MasterSlaveLoadBalanceAlgorithmType.getDefaultAlgorithmType().getAlgorithm() : config.getLoadBalanceAlgorithm();
         Preconditions.checkNotNull(name);
         Preconditions.checkNotNull(masterDataSourceName);
         Preconditions.checkNotNull(slaveDataSourceNames);
         Preconditions.checkState(!slaveDataSourceNames.isEmpty());
-        this.name = name;
-        this.masterDataSourceName = masterDataSourceName;
-        this.slaveDataSourceNames = slaveDataSourceNames;
-        this.strategy = null == strategy ? MasterSlaveLoadBalanceAlgorithmType.getDefaultAlgorithmType().getAlgorithm() : strategy;
     }
 }

sharding-core/src/main/java/io/shardingjdbc/core/yaml/masterslave/YamlMasterSlaveRuleConfiguration.java

@@ -17,8 +17,11 @@
 
 package io.shardingjdbc.core.yaml.masterslave;
 
+import com.google.common.base.Strings;
+import io.shardingjdbc.core.api.algorithm.masterslave.MasterSlaveLoadBalanceAlgorithm;
 import io.shardingjdbc.core.api.algorithm.masterslave.MasterSlaveLoadBalanceAlgorithmType;
 import io.shardingjdbc.core.api.config.MasterSlaveRuleConfiguration;
+import io.shardingjdbc.core.exception.ShardingConfigurationException;
 import lombok.Getter;
 import lombok.Setter;
 
@@ -58,8 +61,23 @@ public class YamlMasterSlaveRuleConfiguration {
         result.setName(name);
         result.setMasterDataSourceName(masterDataSourceName);
         result.setSlaveDataSourceNames(slaveDataSourceNames);
-        result.setLoadBalanceAlgorithmType(loadBalanceAlgorithmType);
-        result.setLoadBalanceAlgorithmClassName(loadBalanceAlgorithmClassName);
+        if (null != loadBalanceAlgorithmType) {
+            result.setLoadBalanceAlgorithm(loadBalanceAlgorithmType.getAlgorithm());
+        } else if (!Strings.isNullOrEmpty(loadBalanceAlgorithmClassName)) {
+            result.setLoadBalanceAlgorithm(newInstance(loadBalanceAlgorithmClassName));
+        }
         return result;
     }
+    
+    private MasterSlaveLoadBalanceAlgorithm newInstance(final String masterSlaveLoadBalanceAlgorithmClassName) {
+        try {
+            Class<?> result = Class.forName(masterSlaveLoadBalanceAlgorithmClassName);
+            if (!MasterSlaveLoadBalanceAlgorithm.class.isAssignableFrom(result)) {
+                throw new ShardingConfigurationException("Class %s should be implement %s", masterSlaveLoadBalanceAlgorithmClassName, MasterSlaveLoadBalanceAlgorithm.class.getName());
+            }
+            return (MasterSlaveLoadBalanceAlgorithm) result.newInstance();
+        } catch (final ReflectiveOperationException ex) {
+            throw new ShardingConfigurationException("Class %s should have public privilege and no argument constructor", masterSlaveLoadBalanceAlgorithmClassName);
+        }
+    }
 }

sharding-core/src/main/java/io/shardingjdbc/core/yaml/sharding/YamlShardingRuleConfiguration.java

@@ -83,13 +83,9 @@ public class YamlShardingRuleConfiguration {
         result.setDefaultKeyGeneratorClass(defaultKeyGeneratorClass);
         Collection<MasterSlaveRuleConfiguration> masterSlaveRuleConfigs = new LinkedList<>();
         for (Entry<String, YamlMasterSlaveRuleConfiguration> entry : masterSlaveRules.entrySet()) {
-            MasterSlaveRuleConfiguration msRuleConfig = new MasterSlaveRuleConfiguration();
-            msRuleConfig.setName(entry.getKey());
-            msRuleConfig.setMasterDataSourceName(entry.getValue().getMasterDataSourceName());
-            msRuleConfig.setSlaveDataSourceNames(entry.getValue().getSlaveDataSourceNames());
-            msRuleConfig.setLoadBalanceAlgorithmType(entry.getValue().getLoadBalanceAlgorithmType());
-            msRuleConfig.setLoadBalanceAlgorithmClassName(entry.getValue().getLoadBalanceAlgorithmClassName());
-            masterSlaveRuleConfigs.add(msRuleConfig);
+            MasterSlaveRuleConfiguration each = entry.getValue().getMasterSlaveRuleConfiguration();
+            each.setName(entry.getKey());
+            masterSlaveRuleConfigs.add(each);
         }
         result.setMasterSlaveRuleConfigs(masterSlaveRuleConfigs);
         return result;

sharding-core/src/test/java/io/shardingjdbc/core/yaml/masterslave/YamlMasterSlaveRuleConfigurationTest.java

@@ -49,7 +49,6 @@ public final class YamlMasterSlaveRuleConfigurationTest {
         assertThat(actual.getName(), is("master_slave_ds"));
         assertThat(actual.getMasterDataSourceName(), is("master_ds"));
         assertThat(actual.getSlaveDataSourceNames(), CoreMatchers.<Collection<String>>is(Arrays.asList("slave_ds_0", "slave_ds_1")));
-        assertThat(actual.getLoadBalanceAlgorithmType(), is(MasterSlaveLoadBalanceAlgorithmType.RANDOM));
-        assertThat(actual.getLoadBalanceAlgorithmClassName(), is("TestLoadBalanceAlgorithmClassName"));
+        assertThat(actual.getLoadBalanceAlgorithm(), is(MasterSlaveLoadBalanceAlgorithmType.RANDOM.getAlgorithm()));
     }
 }

sharding-core/src/test/java/io/shardingjdbc/core/yaml/sharding/YamlShardingRuleConfigurationTest.java

@@ -99,8 +99,7 @@ public final class YamlShardingRuleConfigurationTest {
         assertThat(actual.getName(), is("master_slave_ds"));
         assertThat(actual.getMasterDataSourceName(), is("master_ds"));
         assertThat(actual.getSlaveDataSourceNames(), CoreMatchers.<Collection<String>>is(Arrays.asList("slave_ds_0", "slave_ds_1")));
-        assertThat(actual.getLoadBalanceAlgorithmType(), is(MasterSlaveLoadBalanceAlgorithmType.ROUND_ROBIN));
-        assertThat(actual.getLoadBalanceAlgorithmClassName(), is("TestLoadBalanceAlgorithmClassName"));
+        assertThat(actual.getLoadBalanceAlgorithm(), is(MasterSlaveLoadBalanceAlgorithmType.ROUND_ROBIN.getAlgorithm()));
     }
     
     private void assertWithoutDefaultStrategy(final ShardingRuleConfiguration actual) {

sharding-jdbc-core-spring/sharding-jdbc-core-spring-namespace/src/main/java/io/shardingjdbc/spring/datasource/SpringMasterSlaveDataSource.java

@@ -19,8 +19,8 @@ package io.shardingjdbc.spring.datasource;
 
 import io.shardingjdbc.core.api.algorithm.masterslave.MasterSlaveLoadBalanceAlgorithm;
 import io.shardingjdbc.core.api.algorithm.masterslave.MasterSlaveLoadBalanceAlgorithmType;
+import io.shardingjdbc.core.api.config.MasterSlaveRuleConfiguration;
 import io.shardingjdbc.core.jdbc.core.datasource.MasterSlaveDataSource;
-import io.shardingjdbc.core.rule.MasterSlaveRule;
 
 import javax.sql.DataSource;
 import java.sql.SQLException;
@@ -36,11 +36,21 @@ public class SpringMasterSlaveDataSource extends MasterSlaveDataSource {
     
     public SpringMasterSlaveDataSource(final Map<String, DataSource> dataSourceMap, final String name, final String masterDataSourceName, final Collection<String> slaveDataSourceNames, 
                                        final MasterSlaveLoadBalanceAlgorithm strategy, final Map<String, Object> configMap) throws SQLException {
-        super(dataSourceMap, new MasterSlaveRule(name, masterDataSourceName, slaveDataSourceNames, strategy), configMap);
+        super(dataSourceMap, getMasterSlaveRuleConfiguration(name, masterDataSourceName, slaveDataSourceNames, strategy), configMap);
     }
     
     public SpringMasterSlaveDataSource(final Map<String, DataSource> dataSourceMap, final String name, final String masterDataSourceName, final Collection<String> slaveDataSourceNames, 
                                        final MasterSlaveLoadBalanceAlgorithmType strategyType, final Map<String, Object> configMap) throws SQLException {
-        super(dataSourceMap, new MasterSlaveRule(name, masterDataSourceName, slaveDataSourceNames, strategyType.getAlgorithm()), configMap);
+        super(dataSourceMap, getMasterSlaveRuleConfiguration(name, masterDataSourceName, slaveDataSourceNames, strategyType.getAlgorithm()), configMap);
+    }
+    
+    private static MasterSlaveRuleConfiguration getMasterSlaveRuleConfiguration(
+            final String name, final String masterDataSourceName, final Collection<String> slaveDataSourceNames, final MasterSlaveLoadBalanceAlgorithm loadBalanceAlgorithm) {
+        MasterSlaveRuleConfiguration result = new MasterSlaveRuleConfiguration();
+        result.setName(name);
+        result.setMasterDataSourceName(masterDataSourceName);
+        result.setSlaveDataSourceNames(slaveDataSourceNames);
+        result.setLoadBalanceAlgorithm(loadBalanceAlgorithm);
+        return result;
     }
 }

sharding-jdbc-core-spring/sharding-jdbc-core-spring-namespace/src/test/java/io/shardingjdbc/spring/MasterSlaveNamespaceTest.java

@@ -56,15 +56,15 @@ public class MasterSlaveNamespaceTest extends AbstractJUnit4SpringContextTests {
     public void assertTypeMasterSlaveDataSource() {
         MasterSlaveRule randomSlaveRule = getMasterSlaveRule("randomMasterSlaveDataSource");
         MasterSlaveRule roundRobinSlaveRule = getMasterSlaveRule("roundRobinMasterSlaveDataSource");
-        assertTrue(randomSlaveRule.getStrategy() instanceof RandomMasterSlaveLoadBalanceAlgorithm);
-        assertTrue(roundRobinSlaveRule.getStrategy() instanceof RoundRobinMasterSlaveLoadBalanceAlgorithm);
+        assertTrue(randomSlaveRule.getLoadBalanceAlgorithm() instanceof RandomMasterSlaveLoadBalanceAlgorithm);
+        assertTrue(roundRobinSlaveRule.getLoadBalanceAlgorithm() instanceof RoundRobinMasterSlaveLoadBalanceAlgorithm);
     }
     
     @Test
     public void assertRefMasterSlaveDataSource() {
         MasterSlaveLoadBalanceAlgorithm randomStrategy = this.applicationContext.getBean("randomStrategy", MasterSlaveLoadBalanceAlgorithm.class);
         MasterSlaveRule masterSlaveRule = getMasterSlaveRule("refMasterSlaveDataSource");
-        assertTrue(masterSlaveRule.getStrategy() == randomStrategy);
+        assertTrue(masterSlaveRule.getLoadBalanceAlgorithm() == randomStrategy);
     }
     
     @Test

sharding-jdbc-core/src/main/java/io/shardingjdbc/core/api/MasterSlaveDataSourceFactory.java

@@ -50,7 +50,7 @@ public final class MasterSlaveDataSourceFactory {
      */
     public static DataSource createDataSource(
             final Map<String, DataSource> dataSourceMap, final MasterSlaveRuleConfiguration masterSlaveRuleConfig, final Map<String, Object> configMap) throws SQLException {
-        return new MasterSlaveDataSource(dataSourceMap, masterSlaveRuleConfig.build(), configMap);
+        return new MasterSlaveDataSource(dataSourceMap, masterSlaveRuleConfig, configMap);
     }
     
     /**

sharding-jdbc-core/src/main/java/io/shardingjdbc/core/jdbc/core/datasource/MasterSlaveDataSource.java

@@ -18,6 +18,7 @@
 package io.shardingjdbc.core.jdbc.core.datasource;
 
 import io.shardingjdbc.core.api.ConfigMapContext;
+import io.shardingjdbc.core.api.config.MasterSlaveRuleConfiguration;
 import io.shardingjdbc.core.constant.SQLType;
 import io.shardingjdbc.core.hint.HintManagerHolder;
 import io.shardingjdbc.core.jdbc.adapter.AbstractDataSourceAdapter;
@@ -54,13 +55,13 @@ public class MasterSlaveDataSource extends AbstractDataSourceAdapter {
     
     private MasterSlaveRule masterSlaveRule;
     
-    public MasterSlaveDataSource(final Map<String, DataSource> dataSourceMap, final MasterSlaveRule masterSlaveRule, final Map<String, Object> configMap) throws SQLException {
-        super(getAllDataSources(dataSourceMap, masterSlaveRule.getMasterDataSourceName(), masterSlaveRule.getSlaveDataSourceNames()));
+    public MasterSlaveDataSource(final Map<String, DataSource> dataSourceMap, final MasterSlaveRuleConfiguration masterSlaveRuleConfig, final Map<String, Object> configMap) throws SQLException {
+        super(getAllDataSources(dataSourceMap, masterSlaveRuleConfig.getMasterDataSourceName(), masterSlaveRuleConfig.getSlaveDataSourceNames()));
         this.dataSourceMap = dataSourceMap;
+        this.masterSlaveRule = new MasterSlaveRule(masterSlaveRuleConfig);
         if (!configMap.isEmpty()) {
             ConfigMapContext.getInstance().getMasterSlaveConfig().putAll(configMap);
         }
-        this.masterSlaveRule = masterSlaveRule;
     }
     
     private static Collection<DataSource> getAllDataSources(final Map<String, DataSource> dataSourceMap, final String masterDataSourceName, final Collection<String> slaveDataSourceNames) {
@@ -115,7 +116,7 @@ public class MasterSlaveDataSource extends AbstractDataSourceAdapter {
             DML_FLAG.set(true);
             return new NamedDataSource(masterSlaveRule.getMasterDataSourceName(), dataSourceMap.get(masterSlaveRule.getMasterDataSourceName()));
         }
-        String selectedSourceName = masterSlaveRule.getStrategy().getDataSource(
+        String selectedSourceName = masterSlaveRule.getLoadBalanceAlgorithm().getDataSource(
                 masterSlaveRule.getName(), masterSlaveRule.getMasterDataSourceName(), new ArrayList<>(masterSlaveRule.getSlaveDataSourceNames()));
         DataSource selectedSource = dataSourceMap.get(selectedSourceName);
         return new NamedDataSource(selectedSourceName, selectedSource);
@@ -129,11 +130,11 @@ public class MasterSlaveDataSource extends AbstractDataSourceAdapter {
      * Renew master-slave data source.
      *
      * @param dataSourceMap data source map
-     * @param masterSlaveRule new master-slave rule
+     * @param masterSlaveRuleConfig new master-slave rule configuration
      */
-    public void renew(final Map<String, DataSource> dataSourceMap, final MasterSlaveRule masterSlaveRule) {
+    public void renew(final Map<String, DataSource> dataSourceMap, final MasterSlaveRuleConfiguration masterSlaveRuleConfig) {
         this.dataSourceMap = dataSourceMap;
-        this.masterSlaveRule = masterSlaveRule;
+        this.masterSlaveRule = new MasterSlaveRule(masterSlaveRuleConfig);
     }
     
     @Override

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

@@ -18,6 +18,7 @@
 package io.shardingjdbc.core.integrate.type.sharding;
 
 import com.google.common.base.Joiner;
+import io.shardingjdbc.core.api.config.MasterSlaveRuleConfiguration;
 import io.shardingjdbc.core.api.config.ShardingRuleConfiguration;
 import io.shardingjdbc.core.api.config.TableRuleConfiguration;
 import io.shardingjdbc.core.api.config.strategy.StandardShardingStrategyConfiguration;
@@ -30,7 +31,6 @@ import io.shardingjdbc.core.integrate.fixture.RangeModuloDatabaseShardingAlgorit
 import io.shardingjdbc.core.integrate.jaxb.SQLShardingRule;
 import io.shardingjdbc.core.jdbc.core.datasource.MasterSlaveDataSource;
 import io.shardingjdbc.core.jdbc.core.datasource.ShardingDataSource;
-import io.shardingjdbc.core.rule.MasterSlaveRule;
 import org.junit.After;
 
 import javax.sql.DataSource;
@@ -155,10 +155,13 @@ public abstract class AbstractShardingMasterSlaveTest extends AbstractSQLAssertT
         return result;
     }
     
-    private MasterSlaveDataSource getMasterSlaveDataSource(final Map<String, DataSource> masterSlaveDataSourceMap, 
-                                                           final String name, final String masterDataSourceName, final String slaveDataSourceName) throws SQLException {
-        return new MasterSlaveDataSource(
-                masterSlaveDataSourceMap, new MasterSlaveRule(name, masterDataSourceName, Collections.singleton(slaveDataSourceName)), Collections.<String, Object>emptyMap());
+    private MasterSlaveDataSource getMasterSlaveDataSource(
+            final Map<String, DataSource> masterSlaveDataSourceMap, final String name, final String masterDataSourceName, final String slaveDataSourceName) throws SQLException {
+        MasterSlaveRuleConfiguration config = new MasterSlaveRuleConfiguration();
+        config.setName(name);
+        config.setMasterDataSourceName(masterDataSourceName);
+        config.setSlaveDataSourceNames(Collections.singleton(slaveDataSourceName));
+        return new MasterSlaveDataSource(masterSlaveDataSourceMap, config, Collections.<String, Object>emptyMap());
     }
     
     @After

sharding-jdbc-core/src/test/java/io/shardingjdbc/core/jdbc/core/connection/ShardingConnectionTest.java

@@ -17,13 +17,13 @@
 
 package io.shardingjdbc.core.jdbc.core.connection;
 
+import io.shardingjdbc.core.api.config.MasterSlaveRuleConfiguration;
 import io.shardingjdbc.core.api.config.ShardingRuleConfiguration;
 import io.shardingjdbc.core.api.config.TableRuleConfiguration;
 import io.shardingjdbc.core.constant.SQLType;
 import io.shardingjdbc.core.fixture.TestDataSource;
 import io.shardingjdbc.core.jdbc.core.ShardingContext;
 import io.shardingjdbc.core.jdbc.core.datasource.MasterSlaveDataSource;
-import io.shardingjdbc.core.rule.MasterSlaveRule;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.BeforeClass;
@@ -54,8 +54,11 @@ public final class ShardingConnectionTest {
         Map<String, DataSource> dataSourceMap = new HashMap<>(2, 1);
         dataSourceMap.put("test_ds_master", masterDataSource);
         dataSourceMap.put("test_ds_slave", slaveDataSource);
-        masterSlaveDataSource = new MasterSlaveDataSource(
-                dataSourceMap, new MasterSlaveRule("test_ds", "test_ds_master", Collections.singletonList("test_ds_slave")), Collections.<String, Object>emptyMap());
+        MasterSlaveRuleConfiguration config = new MasterSlaveRuleConfiguration();
+        config.setName("test_ds");
+        config.setMasterDataSourceName("test_ds_master");
+        config.setSlaveDataSourceNames(Collections.singletonList("test_ds_slave"));
+        masterSlaveDataSource = new MasterSlaveDataSource(dataSourceMap, config, Collections.<String, Object>emptyMap());
         ((TestDataSource) slaveDataSource).setThrowExceptionWhenClosing(true);
     }
     

sharding-jdbc-core/src/test/java/io/shardingjdbc/core/jdbc/core/datasource/MasterSlaveDataSourceTest.java

@@ -20,7 +20,6 @@ package io.shardingjdbc.core.jdbc.core.datasource;
 import io.shardingjdbc.core.api.HintManager;
 import io.shardingjdbc.core.api.MasterSlaveDataSourceFactory;
 import io.shardingjdbc.core.api.config.MasterSlaveRuleConfiguration;
-import io.shardingjdbc.core.rule.MasterSlaveRule;
 import io.shardingjdbc.core.constant.DatabaseType;
 import io.shardingjdbc.core.constant.SQLType;
 import io.shardingjdbc.core.fixture.TestDataSource;
@@ -60,8 +59,11 @@ public final class MasterSlaveDataSourceTest {
         Map<String, DataSource> dataSourceMap = new HashMap<>(2, 1);
         dataSourceMap.put("test_ds_master", masterDataSource);
         dataSourceMap.put("test_ds_slave", slaveDataSource);
-        masterSlaveDataSource = new MasterSlaveDataSource(
-                dataSourceMap, new MasterSlaveRule("test_ds", "test_ds_master", Collections.singletonList("test_ds_slave")), Collections.<String, Object>emptyMap());
+        MasterSlaveRuleConfiguration config = new MasterSlaveRuleConfiguration();
+        config.setName("test_ds");
+        config.setMasterDataSourceName("test_ds_master");
+        config.setSlaveDataSourceNames(Collections.singletonList("test_ds_slave"));
+        masterSlaveDataSource = new MasterSlaveDataSource(dataSourceMap, config, Collections.<String, Object>emptyMap());
     }
     
     @Before

sharding-jdbc-orchestration-spring/sharding-jdbc-orchestration-spring-namespace/src/main/java/io/shardingjdbc/orchestration/spring/datasource/SpringMasterSlaveDataSource.java

@@ -19,8 +19,8 @@ package io.shardingjdbc.orchestration.spring.datasource;
 
 import io.shardingjdbc.core.api.algorithm.masterslave.MasterSlaveLoadBalanceAlgorithm;
 import io.shardingjdbc.core.api.algorithm.masterslave.MasterSlaveLoadBalanceAlgorithmType;
+import io.shardingjdbc.core.api.config.MasterSlaveRuleConfiguration;
 import io.shardingjdbc.core.jdbc.core.datasource.MasterSlaveDataSource;
-import io.shardingjdbc.core.rule.MasterSlaveRule;
 
 import javax.sql.DataSource;
 import java.sql.SQLException;
@@ -37,11 +37,21 @@ public class SpringMasterSlaveDataSource extends MasterSlaveDataSource {
     
     public SpringMasterSlaveDataSource(final Map<String, DataSource> dataSourceMap, final String name, 
                                        final String masterDataSourceName, final Collection<String> slaveDataSourceNames, final MasterSlaveLoadBalanceAlgorithm strategy) throws SQLException {
-        super(dataSourceMap, new MasterSlaveRule(name, masterDataSourceName, slaveDataSourceNames, strategy), Collections.<String, Object>emptyMap());
+        super(dataSourceMap, getMasterSlaveRuleConfiguration(name, masterDataSourceName, slaveDataSourceNames, strategy), Collections.<String, Object>emptyMap());
     }
     
     public SpringMasterSlaveDataSource(final Map<String, DataSource> dataSourceMap, final String name, 
                                        final String masterDataSourceName, final Collection<String> slaveDataSourceNames, final MasterSlaveLoadBalanceAlgorithmType strategyType) throws SQLException {
-        super(dataSourceMap, new MasterSlaveRule(name, masterDataSourceName, slaveDataSourceNames, strategyType.getAlgorithm()), Collections.<String, Object>emptyMap());
+        super(dataSourceMap, getMasterSlaveRuleConfiguration(name, masterDataSourceName, slaveDataSourceNames, strategyType.getAlgorithm()), Collections.<String, Object>emptyMap());
+    }
+    
+    private static MasterSlaveRuleConfiguration getMasterSlaveRuleConfiguration(
+            final String name, final String masterDataSourceName, final Collection<String> slaveDataSourceNames, final MasterSlaveLoadBalanceAlgorithm loadBalanceAlgorithm) {
+        MasterSlaveRuleConfiguration result = new MasterSlaveRuleConfiguration();
+        result.setName(name);
+        result.setMasterDataSourceName(masterDataSourceName);
+        result.setSlaveDataSourceNames(slaveDataSourceNames);
+        result.setLoadBalanceAlgorithm(loadBalanceAlgorithm);
+        return result;
     }
 }

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

@@ -75,7 +75,7 @@ public class OrchestrationMasterSlaveDataSourceBeanDefinitionParser extends Abst
     private AbstractBeanDefinition getOrchestrationSpringMasterSlaveDataSourceBean(final Element element, final ParserContext parserContext) {
         BeanDefinitionBuilder factory = BeanDefinitionBuilder.rootBeanDefinition(OrchestrationMasterSlaveDataSource.class);
         factory.addConstructorArgValue(parseDataSources(element));
-        factory.addConstructorArgValue(parseMasterSlaveRuleConfig(element, parserContext));
+        factory.addConstructorArgValue(parseMasterSlaveRuleConfig(element));
         factory.addConstructorArgValue(parseConfigMap(element, parserContext, factory.getBeanDefinition()));
         factory.addConstructorArgValue(parseOrchestrationConfiguration(element));
         factory.setInitMethodName("init");
@@ -101,16 +101,17 @@ public class OrchestrationMasterSlaveDataSourceBeanDefinitionParser extends Abst
         return element.getAttribute("registry-center-ref");
     }
     
-    private BeanDefinition parseMasterSlaveRuleConfig(final Element element, final ParserContext parserContext) {
+    private BeanDefinition parseMasterSlaveRuleConfig(final Element element) {
         BeanDefinitionBuilder factory = BeanDefinitionBuilder.rootBeanDefinition(MasterSlaveRuleConfiguration.class);
         factory.addPropertyValue("name", parseId(element));
         factory.addPropertyValue("masterDataSourceName", parseMasterDataSourceRef(element));
         factory.addPropertyValue("slaveDataSourceNames", parseSlaveDataSources(element));
         String strategyRef = parseStrategyRef(element);
+        MasterSlaveLoadBalanceAlgorithmType strategyType = parseStrategyType(element);
         if (!Strings.isNullOrEmpty(strategyRef)) {
-            factory.addPropertyValue("loadBalanceAlgorithmClassName", parserContext.getRegistry().getBeanDefinition(strategyRef).getBeanClassName());
-        } else {
-            factory.addPropertyValue("loadBalanceAlgorithmType", parseStrategyType(element));
+            factory.addPropertyReference("loadBalanceAlgorithm", strategyRef);
+        } else if (null != strategyType) {
+            factory.addPropertyValue("loadBalanceAlgorithm", strategyType.getAlgorithm());
         }
         return factory.getBeanDefinition();
     }
@@ -136,7 +137,7 @@ public class OrchestrationMasterSlaveDataSourceBeanDefinitionParser extends Abst
     
     private MasterSlaveLoadBalanceAlgorithmType parseStrategyType(final Element element) {
         String result = element.getAttribute(MasterSlaveDataSourceBeanDefinitionParserTag.STRATEGY_TYPE_ATTRIBUTE);
-        return Strings.isNullOrEmpty(result) ? MasterSlaveLoadBalanceAlgorithmType.getDefaultAlgorithmType() : MasterSlaveLoadBalanceAlgorithmType.valueOf(result);
+        return Strings.isNullOrEmpty(result) ? null : MasterSlaveLoadBalanceAlgorithmType.valueOf(result);
     }
     
     private Map parseConfigMap(final Element element, final ParserContext parserContext, final BeanDefinition beanDefinition) {

sharding-jdbc-orchestration-spring/sharding-jdbc-orchestration-spring-namespace/src/test/java/io/shardingjdbc/orchestration/spring/OrchestrationMasterSlaveNamespaceTest.java

@@ -65,15 +65,15 @@ public class OrchestrationMasterSlaveNamespaceTest extends AbstractJUnit4SpringC
     public void assertTypeMasterSlaveDataSource() {
         MasterSlaveRule randomSlaveRule = getMasterSlaveRule("randomMasterSlaveDataSource");
         MasterSlaveRule roundRobinSlaveRule = getMasterSlaveRule("roundRobinMasterSlaveDataSource");
-        assertTrue(randomSlaveRule.getStrategy() instanceof RandomMasterSlaveLoadBalanceAlgorithm);
-        assertTrue(roundRobinSlaveRule.getStrategy() instanceof RoundRobinMasterSlaveLoadBalanceAlgorithm);
+        assertTrue(randomSlaveRule.getLoadBalanceAlgorithm() instanceof RandomMasterSlaveLoadBalanceAlgorithm);
+        assertTrue(roundRobinSlaveRule.getLoadBalanceAlgorithm() instanceof RoundRobinMasterSlaveLoadBalanceAlgorithm);
     }
     
     @Test
     public void assertRefMasterSlaveDataSource() {
         MasterSlaveLoadBalanceAlgorithm randomStrategy = this.applicationContext.getBean("randomStrategy", MasterSlaveLoadBalanceAlgorithm.class);
         MasterSlaveRule masterSlaveRule = getMasterSlaveRule("refMasterSlaveDataSource");
-        assertTrue(EqualsBuilder.reflectionEquals(masterSlaveRule.getStrategy(), randomStrategy));
+        assertTrue(EqualsBuilder.reflectionEquals(masterSlaveRule.getLoadBalanceAlgorithm(), randomStrategy));
     }
     
     private MasterSlaveRule getMasterSlaveRule(final String masterSlaveDataSourceName) {

sharding-jdbc-orchestration/src/main/java/io/shardingjdbc/orchestration/internal/OrchestrationFacade.java

@@ -145,7 +145,7 @@ public final class OrchestrationFacade implements AutoCloseable {
         result.setName(masterSlaveDataSource.getMasterSlaveRule().getName());
         result.setMasterDataSourceName(masterSlaveDataSource.getMasterSlaveRule().getMasterDataSourceName());
         result.setSlaveDataSourceNames(masterSlaveDataSource.getMasterSlaveRule().getSlaveDataSourceNames());
-        result.setLoadBalanceAlgorithmClassName(masterSlaveDataSource.getMasterSlaveRule().getStrategy().getClass().getName());
+        result.setLoadBalanceAlgorithm(masterSlaveDataSource.getMasterSlaveRule().getLoadBalanceAlgorithm());
         return result;
     }
     

sharding-jdbc-orchestration/src/main/java/io/shardingjdbc/orchestration/internal/OrchestrationMasterSlaveDataSource.java

@@ -44,7 +44,7 @@ public class OrchestrationMasterSlaveDataSource extends MasterSlaveDataSource im
     
     public OrchestrationMasterSlaveDataSource(final Map<String, DataSource> dataSourceMap, final MasterSlaveRuleConfiguration masterSlaveRuleConfig,
                                               final Map<String, Object> configMap, final OrchestrationConfiguration config) throws SQLException {
-        super(dataSourceMap, masterSlaveRuleConfig.build(), configMap);
+        super(dataSourceMap, masterSlaveRuleConfig, configMap);
         orchestrationFacade = new OrchestrationFacade(config);
         this.dataSourceMap = dataSourceMap;
         this.masterSlaveRuleConfig = masterSlaveRuleConfig;

sharding-jdbc-orchestration/src/main/java/io/shardingjdbc/orchestration/internal/config/ConfigurationListenerManager.java

@@ -84,7 +84,7 @@ public final class ConfigurationListenerManager implements ListenerManager {
             @Override
             public void onChange(final DataChangedEvent event) {
                 if (DataChangedEvent.Type.UPDATED == event.getEventType()) {
-                    masterSlaveDataSource.renew(dataSourceService.getAvailableDataSources(), dataSourceService.getAvailableMasterSlaveRuleConfiguration().build());
+                    masterSlaveDataSource.renew(dataSourceService.getAvailableDataSources(), dataSourceService.getAvailableMasterSlaveRuleConfiguration());
                 }
             }
         });

sharding-jdbc-orchestration/src/main/java/io/shardingjdbc/orchestration/internal/state/datasource/DataSourceListenerManager.java

@@ -78,7 +78,7 @@ public final class DataSourceListenerManager implements ListenerManager {
                     if (masterSlaveRuleConfiguration.getSlaveDataSourceNames().isEmpty()) {
                         throw new ShardingJdbcException("No available slave datasource, can't apply the configuration!");
                     } 
-                    masterSlaveDataSource.renew(dataSourceService.getAvailableDataSources(), masterSlaveRuleConfiguration.build());
+                    masterSlaveDataSource.renew(dataSourceService.getAvailableDataSources(), masterSlaveRuleConfiguration);
                 }
             }
         });

sharding-jdbc-orchestration/src/main/java/io/shardingjdbc/orchestration/internal/state/instance/InstanceListenerManager.java

@@ -82,7 +82,7 @@ public final class InstanceListenerManager implements ListenerManager {
                             dataSourceMap.put(each, new CircuitBreakerDataSource());
                         }
                     }
-                    masterSlaveDataSource.renew(dataSourceMap, configService.loadMasterSlaveRuleConfiguration().build());
+                    masterSlaveDataSource.renew(dataSourceMap, configService.loadMasterSlaveRuleConfiguration());
                 }
             }
         });