for #85 master slave example

sharding-jdbc-example/pom.xml

@@ -12,6 +12,8 @@
         <module>sharding-jdbc-example-config-yaml</module>
         <module>sharding-jdbc-example-config-spring</module>
         <module>sharding-jdbc-example-jdbc-transaction</module>
+        <module>sharding-jdbc-example-jdbc-masterslave</module>
+        <module>sharding-jdbc-example-spring-masterslave</module>
     </modules>
     
     <properties>

sharding-jdbc-example/sharding-jdbc-example-jdbc-masterslave/pom.xml

+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>sharding-jdbc-example</artifactId>
+        <groupId>com.dangdang</groupId>
+        <version>1.2.2-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>sharding-jdbc-example-jdbc-masterslave</artifactId>
+</project>
\ No newline at end of file

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

+/*
+ * Copyright 1999-2015 dangdang.com.
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * </p>
+ */
+
+package com.dangdang.ddframe.rdb.sharding.example.jdbc.masterslave;
+
+import com.dangdang.ddframe.rdb.sharding.api.HintManager;
+import com.dangdang.ddframe.rdb.sharding.api.MasterSlaveDataSourceFactory;
+import com.dangdang.ddframe.rdb.sharding.api.rule.BindingTableRule;
+import com.dangdang.ddframe.rdb.sharding.api.rule.DataSourceRule;
+import com.dangdang.ddframe.rdb.sharding.api.rule.ShardingRule;
+import com.dangdang.ddframe.rdb.sharding.api.rule.TableRule;
+import com.dangdang.ddframe.rdb.sharding.api.strategy.database.DatabaseShardingStrategy;
+import com.dangdang.ddframe.rdb.sharding.api.strategy.table.TableShardingStrategy;
+import com.dangdang.ddframe.rdb.sharding.example.jdbc.masterslave.algorithm.ModuloDatabaseShardingAlgorithm;
+import com.dangdang.ddframe.rdb.sharding.example.jdbc.masterslave.algorithm.ModuloTableShardingAlgorithm;
+import com.dangdang.ddframe.rdb.sharding.jdbc.ShardingDataSource;
+import org.apache.commons.dbcp.BasicDataSource;
+
+import javax.sql.DataSource;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+public final class Main {
+    
+    // CHECKSTYLE:OFF
+    public static void main(final String[] args) throws SQLException {
+    // CHECKSTYLE:ON
+        DataSource dataSource = getShardingDataSource();
+        printSimpleSelect(dataSource);
+        System.out.println("--------------");
+        printGroupBy(dataSource);
+        System.out.println("--------------");
+        printHintSimpleSelect(dataSource);
+    }
+    
+    private static void printSimpleSelect(final DataSource dataSource) throws SQLException {
+        String sql = "SELECT i.* FROM t_order o JOIN t_order_item i ON o.order_id=i.order_id WHERE o.user_id=? AND o.order_id=?";
+        try (
+                Connection conn = dataSource.getConnection();
+                PreparedStatement preparedStatement = conn.prepareStatement(sql)) {
+            preparedStatement.setInt(1, 10);
+            preparedStatement.setInt(2, 1001);
+            try (ResultSet rs = preparedStatement.executeQuery()) {
+                while (rs.next()) {
+                    System.out.println(rs.getInt(1));
+                    System.out.println(rs.getInt(2));
+                    System.out.println(rs.getInt(3));
+                }
+            }
+        }
+    }
+    
+    private static void printGroupBy(final DataSource dataSource) throws SQLException {
+        String sql = "SELECT o.user_id, COUNT(*) FROM t_order o JOIN t_order_item i ON o.order_id=i.order_id GROUP BY o.user_id";
+        try (
+                Connection conn = dataSource.getConnection();
+                PreparedStatement preparedStatement = conn.prepareStatement(sql)
+                ) {
+            ResultSet rs = preparedStatement.executeQuery();
+            while (rs.next()) {
+                System.out.println("user_id: " + rs.getInt(1) + ", count: " + rs.getInt(2));
+            }
+        }
+    }
+    
+    private static void printHintSimpleSelect(final DataSource dataSource) throws SQLException {
+        String sql = "SELECT i.* FROM t_order o JOIN t_order_item i ON o.order_id=i.order_id";
+        try (
+                HintManager hintManager = HintManager.getInstance();
+                Connection conn = dataSource.getConnection();
+                PreparedStatement preparedStatement = conn.prepareStatement(sql)) {
+            hintManager.addDatabaseShardingValue("t_order", "user_id", 10);
+            hintManager.addTableShardingValue("t_order", "order_id", 1001);
+            try (ResultSet rs = preparedStatement.executeQuery()) {
+                while (rs.next()) {
+                    System.out.println(rs.getInt(1));
+                    System.out.println(rs.getInt(2));
+                    System.out.println(rs.getInt(3));
+                }
+            }
+        }
+    }
+    
+    private static ShardingDataSource getShardingDataSource() {
+        DataSourceRule dataSourceRule = new DataSourceRule(createDataSourceMap());
+        TableRule orderTableRule = TableRule.builder("t_order").actualTables(Arrays.asList("t_order_0", "t_order_1")).dataSourceRule(dataSourceRule).build();
+        TableRule orderItemTableRule = TableRule.builder("t_order_item").actualTables(Arrays.asList("t_order_item_0", "t_order_item_1")).dataSourceRule(dataSourceRule).build();
+        ShardingRule shardingRule = ShardingRule.builder().dataSourceRule(dataSourceRule).tableRules(Arrays.asList(orderTableRule, orderItemTableRule))
+                .bindingTableRules(Collections.singletonList(new BindingTableRule(Arrays.asList(orderTableRule, orderItemTableRule))))
+                .databaseShardingStrategy(new DatabaseShardingStrategy("user_id", new ModuloDatabaseShardingAlgorithm()))
+                .tableShardingStrategy(new TableShardingStrategy("order_id", new ModuloTableShardingAlgorithm())).build();
+        return new ShardingDataSource(shardingRule);
+    }
+    
+    private static Map<String, DataSource> createDataSourceMap() {
+        Map<String, DataSource> result = new HashMap<>(2);
+        result.put("ds_0", MasterSlaveDataSourceFactory.createDataSource("ds_0", createDataSource("ds_0_master"), createDataSource("ds_0_slave_0"), createDataSource("ds_0_slave_1")));
+        result.put("ds_1", MasterSlaveDataSourceFactory.createDataSource("ds_1", createDataSource("ds_1_master"), createDataSource("ds_1_slave_0"), createDataSource("ds_1_slave_1")));
+        return result;
+    }
+    
+    private static DataSource createDataSource(final String dataSourceName) {
+        BasicDataSource result = new BasicDataSource();
+        result.setDriverClassName(com.mysql.jdbc.Driver.class.getName());
+        result.setUrl(String.format("jdbc:mysql://localhost:3306/%s", dataSourceName));
+        result.setUsername("root");
+        result.setPassword("");
+        return result;
+    }
+}

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

+/*
+ * Copyright 1999-2015 dangdang.com.
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * </p>
+ */
+
+package com.dangdang.ddframe.rdb.sharding.example.jdbc.masterslave.algorithm;
+
+import com.dangdang.ddframe.rdb.sharding.api.ShardingValue;
+import com.dangdang.ddframe.rdb.sharding.api.strategy.database.SingleKeyDatabaseShardingAlgorithm;
+import com.google.common.collect.Range;
+
+import java.util.Collection;
+import java.util.LinkedHashSet;
+
+public final class ModuloDatabaseShardingAlgorithm implements SingleKeyDatabaseShardingAlgorithm<Integer> {
+    
+    @Override
+    public String doEqualSharding(final Collection<String> dataSourceNames, final ShardingValue<Integer> shardingValue) {
+        for (String each : dataSourceNames) {
+            if (each.endsWith(shardingValue.getValue() % 2 + "")) {
+                return each;
+            }
+        }
+        throw new IllegalArgumentException();
+    }
+    
+    @Override
+    public Collection<String> doInSharding(final Collection<String> dataSourceNames, final ShardingValue<Integer> shardingValue) {
+        Collection<String> result = new LinkedHashSet<>(dataSourceNames.size());
+        for (Integer value : shardingValue.getValues()) {
+            for (String dataSourceName : dataSourceNames) {
+                if (dataSourceName.endsWith(value % 2 + "")) {
+                    result.add(dataSourceName);
+                }
+            }
+        }
+        return result;
+    }
+    
+    @Override
+    public Collection<String> doBetweenSharding(final Collection<String> dataSourceNames, final ShardingValue<Integer> shardingValue) {
+        Collection<String> result = new LinkedHashSet<>(dataSourceNames.size());
+        Range<Integer> range = shardingValue.getValueRange();
+        for (Integer i = range.lowerEndpoint(); i <= range.upperEndpoint(); i++) {
+            for (String each : dataSourceNames) {
+                if (each.endsWith(i % 2 + "")) {
+                    result.add(each);
+                }
+            }
+        }
+        return result;
+    }
+}

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

+/*
+ * Copyright 1999-2015 dangdang.com.
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * </p>
+ */
+
+package com.dangdang.ddframe.rdb.sharding.example.jdbc.masterslave.algorithm;
+
+import com.dangdang.ddframe.rdb.sharding.api.ShardingValue;
+import com.dangdang.ddframe.rdb.sharding.api.strategy.table.SingleKeyTableShardingAlgorithm;
+import com.google.common.collect.Range;
+
+import java.util.Collection;
+import java.util.LinkedHashSet;
+
+public final class ModuloTableShardingAlgorithm implements SingleKeyTableShardingAlgorithm<Integer> {
+    
+    @Override
+    public String doEqualSharding(final Collection<String> tableNames, final ShardingValue<Integer> shardingValue) {
+        for (String each : tableNames) {
+            if (each.endsWith(shardingValue.getValue() % 2 + "")) {
+                return each;
+            }
+        }
+        throw new UnsupportedOperationException();
+    }
+    
+    @Override
+    public Collection<String> doInSharding(final Collection<String> tableNames, final ShardingValue<Integer> shardingValue) {
+        Collection<String> result = new LinkedHashSet<>(tableNames.size());
+        for (Integer value : shardingValue.getValues()) {
+            for (String tableName : tableNames) {
+                if (tableName.endsWith(value % 2 + "")) {
+                    result.add(tableName);
+                }
+            }
+        }
+        return result;
+    }
+    
+    @Override
+    public Collection<String> doBetweenSharding(final Collection<String> tableNames, final ShardingValue<Integer> shardingValue) {
+        Collection<String> result = new LinkedHashSet<>(tableNames.size());
+        Range<Integer> range = shardingValue.getValueRange();
+        for (Integer i = range.lowerEndpoint(); i <= range.upperEndpoint(); i++) {
+            for (String each : tableNames) {
+                if (each.endsWith(i % 2 + "")) {
+                    result.add(each);
+                }
+            }
+        }
+        return result;
+    }
+}

sharding-jdbc-example/sharding-jdbc-example-jdbc-masterslave/src/main/resources/all_schema.sql

+CREATE SCHEMA IF NOT EXISTS `ds_0_master`;
+CREATE SCHEMA IF NOT EXISTS `ds_1_master`;
+
+CREATE TABLE IF NOT EXISTS `ds_0_master`.`t_order_0` (`order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(50), PRIMARY KEY (`order_id`));
+CREATE TABLE IF NOT EXISTS `ds_0_master`.`t_order_1` (`order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(50), PRIMARY KEY (`order_id`));
+CREATE TABLE IF NOT EXISTS `ds_0_master`.`t_order_item_0` (`item_id` INT NOT NULL, `order_id` INT NOT NULL, `user_id` INT NOT NULL, PRIMARY KEY (`item_id`));
+CREATE TABLE IF NOT EXISTS `ds_0_master`.`t_order_item_1` (`item_id` INT NOT NULL, `order_id` INT NOT NULL, `user_id` INT NOT NULL, PRIMARY KEY (`item_id`));
+
+CREATE TABLE IF NOT EXISTS `ds_1_master`.`t_order_0` (`order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(50), PRIMARY KEY (`order_id`));
+CREATE TABLE IF NOT EXISTS `ds_1_master`.`t_order_1` (`order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(50), PRIMARY KEY (`order_id`));
+CREATE TABLE IF NOT EXISTS `ds_1_master`.`t_order_item_0` (`item_id` INT NOT NULL, `order_id` INT NOT NULL, `user_id` INT NOT NULL, PRIMARY KEY (`item_id`));
+CREATE TABLE IF NOT EXISTS `ds_1_master`.`t_order_item_1` (`item_id` INT NOT NULL, `order_id` INT NOT NULL, `user_id` INT NOT NULL, PRIMARY KEY (`item_id`));
+
+INSERT INTO `ds_0_master`.`t_order_0` VALUES (1000, 10, 'INIT_MASTER');
+INSERT INTO `ds_0_master`.`t_order_0` VALUES (1002, 10, 'INIT_MASTER');
+INSERT INTO `ds_0_master`.`t_order_0` VALUES (1004, 10, 'INIT_MASTER');
+INSERT INTO `ds_0_master`.`t_order_0` VALUES (1006, 10, 'INIT_MASTER');
+INSERT INTO `ds_0_master`.`t_order_0` VALUES (1008, 10, 'INIT_MASTER');
+INSERT INTO `ds_0_master`.`t_order_item_0` VALUES (100001, 1000, 10);
+INSERT INTO `ds_0_master`.`t_order_item_0` VALUES (100201, 1002, 10);
+INSERT INTO `ds_0_master`.`t_order_item_0` VALUES (100401, 1004, 10);
+INSERT INTO `ds_0_master`.`t_order_item_0` VALUES (100601, 1006, 10);
+INSERT INTO `ds_0_master`.`t_order_item_0` VALUES (100801, 1008, 10);
+
+INSERT INTO `ds_0_master`.`t_order_1` VALUES (1001, 10, 'INIT_MASTER');
+INSERT INTO `ds_0_master`.`t_order_1` VALUES (1003, 10, 'INIT_MASTER');
+INSERT INTO `ds_0_master`.`t_order_1` VALUES (1005, 10, 'INIT_MASTER');
+INSERT INTO `ds_0_master`.`t_order_1` VALUES (1007, 10, 'INIT_MASTER');
+INSERT INTO `ds_0_master`.`t_order_1` VALUES (1009, 10, 'INIT_MASTER');
+INSERT INTO `ds_0_master`.`t_order_item_1` VALUES (100101, 1001, 10);
+INSERT INTO `ds_0_master`.`t_order_item_1` VALUES (100301, 1003, 10);
+INSERT INTO `ds_0_master`.`t_order_item_1` VALUES (100501, 1005, 10);
+INSERT INTO `ds_0_master`.`t_order_item_1` VALUES (100701, 1007, 10);
+INSERT INTO `ds_0_master`.`t_order_item_1` VALUES (100901, 1009, 10);
+
+INSERT INTO `ds_1_master`.`t_order_0` VALUES (1100, 11, 'INIT_MASTER');
+INSERT INTO `ds_1_master`.`t_order_0` VALUES (1102, 11, 'INIT_MASTER');
+INSERT INTO `ds_1_master`.`t_order_0` VALUES (1104, 11, 'INIT_MASTER');
+INSERT INTO `ds_1_master`.`t_order_0` VALUES (1106, 11, 'INIT_MASTER');
+INSERT INTO `ds_1_master`.`t_order_0` VALUES (1108, 11, 'INIT_MASTER');
+INSERT INTO `ds_1_master`.`t_order_item_0` VALUES (110001, 1100, 11);
+INSERT INTO `ds_1_master`.`t_order_item_0` VALUES (110201, 1102, 11);
+INSERT INTO `ds_1_master`.`t_order_item_0` VALUES (110401, 1104, 11);
+INSERT INTO `ds_1_master`.`t_order_item_0` VALUES (110601, 1106, 11);
+INSERT INTO `ds_1_master`.`t_order_item_0` VALUES (110801, 1108, 11);
+
+INSERT INTO `ds_1_master`.`t_order_1` VALUES (1101, 11, 'INIT_MASTER');
+INSERT INTO `ds_1_master`.`t_order_1` VALUES (1103, 11, 'INIT_MASTER');
+INSERT INTO `ds_1_master`.`t_order_1` VALUES (1105, 11, 'INIT_MASTER');
+INSERT INTO `ds_1_master`.`t_order_1` VALUES (1107, 11, 'INIT_MASTER');
+INSERT INTO `ds_1_master`.`t_order_1` VALUES (1109, 11, 'INIT_MASTER');
+INSERT INTO `ds_1_master`.`t_order_item_1` VALUES (110101, 1101, 11);
+INSERT INTO `ds_1_master`.`t_order_item_1` VALUES (110301, 1103, 11);
+INSERT INTO `ds_1_master`.`t_order_item_1` VALUES (110501, 1105, 11);
+INSERT INTO `ds_1_master`.`t_order_item_1` VALUES (110701, 1107, 11);
+INSERT INTO `ds_1_master`.`t_order_item_1` VALUES (110901, 1109, 11);
+
+CREATE SCHEMA IF NOT EXISTS `ds_0_slave_0`;
+CREATE SCHEMA IF NOT EXISTS `ds_1_slave_0`;
+
+CREATE TABLE IF NOT EXISTS `ds_0_slave_0`.`t_order_0` (`order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(50), PRIMARY KEY (`order_id`));
+CREATE TABLE IF NOT EXISTS `ds_0_slave_0`.`t_order_1` (`order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(50), PRIMARY KEY (`order_id`));
+CREATE TABLE IF NOT EXISTS `ds_0_slave_0`.`t_order_item_0` (`item_id` INT NOT NULL, `order_id` INT NOT NULL, `user_id` INT NOT NULL, PRIMARY KEY (`item_id`));
+CREATE TABLE IF NOT EXISTS `ds_0_slave_0`.`t_order_item_1` (`item_id` INT NOT NULL, `order_id` INT NOT NULL, `user_id` INT NOT NULL, PRIMARY KEY (`item_id`));
+
+CREATE TABLE IF NOT EXISTS `ds_1_slave_0`.`t_order_0` (`order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(50), PRIMARY KEY (`order_id`));
+CREATE TABLE IF NOT EXISTS `ds_1_slave_0`.`t_order_1` (`order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(50), PRIMARY KEY (`order_id`));
+CREATE TABLE IF NOT EXISTS `ds_1_slave_0`.`t_order_item_0` (`item_id` INT NOT NULL, `order_id` INT NOT NULL, `user_id` INT NOT NULL, PRIMARY KEY (`item_id`));
+CREATE TABLE IF NOT EXISTS `ds_1_slave_0`.`t_order_item_1` (`item_id` INT NOT NULL, `order_id` INT NOT NULL, `user_id` INT NOT NULL, PRIMARY KEY (`item_id`));
+
+INSERT INTO `ds_0_slave_0`.`t_order_0` VALUES (1000, 10, 'INIT_SLAVE_0');
+INSERT INTO `ds_0_slave_0`.`t_order_0` VALUES (1002, 10, 'INIT_SLAVE_0');
+INSERT INTO `ds_0_slave_0`.`t_order_0` VALUES (1004, 10, 'INIT_SLAVE_0');
+INSERT INTO `ds_0_slave_0`.`t_order_0` VALUES (1006, 10, 'INIT_SLAVE_0');
+INSERT INTO `ds_0_slave_0`.`t_order_0` VALUES (1008, 10, 'INIT_SLAVE_0');
+INSERT INTO `ds_0_slave_0`.`t_order_item_0` VALUES (100001, 1000, 10);
+INSERT INTO `ds_0_slave_0`.`t_order_item_0` VALUES (100201, 1002, 10);
+INSERT INTO `ds_0_slave_0`.`t_order_item_0` VALUES (100401, 1004, 10);
+INSERT INTO `ds_0_slave_0`.`t_order_item_0` VALUES (100601, 1006, 10);
+INSERT INTO `ds_0_slave_0`.`t_order_item_0` VALUES (100801, 1008, 10);
+
+INSERT INTO `ds_0_slave_0`.`t_order_1` VALUES (1001, 10, 'INIT_SLAVE_0');
+INSERT INTO `ds_0_slave_0`.`t_order_1` VALUES (1003, 10, 'INIT_SLAVE_0');
+INSERT INTO `ds_0_slave_0`.`t_order_1` VALUES (1005, 10, 'INIT_SLAVE_0');
+INSERT INTO `ds_0_slave_0`.`t_order_1` VALUES (1007, 10, 'INIT_SLAVE_0');
+INSERT INTO `ds_0_slave_0`.`t_order_1` VALUES (1009, 10, 'INIT_SLAVE_0');
+INSERT INTO `ds_0_slave_0`.`t_order_item_1` VALUES (100101, 1001, 10);
+INSERT INTO `ds_0_slave_0`.`t_order_item_1` VALUES (100301, 1003, 10);
+INSERT INTO `ds_0_slave_0`.`t_order_item_1` VALUES (100501, 1005, 10);
+INSERT INTO `ds_0_slave_0`.`t_order_item_1` VALUES (100701, 1007, 10);
+INSERT INTO `ds_0_slave_0`.`t_order_item_1` VALUES (100901, 1009, 10);
+
+INSERT INTO `ds_1_slave_0`.`t_order_0` VALUES (1100, 11, 'INIT_SLAVE_0');
+INSERT INTO `ds_1_slave_0`.`t_order_0` VALUES (1102, 11, 'INIT_SLAVE_0');
+INSERT INTO `ds_1_slave_0`.`t_order_0` VALUES (1104, 11, 'INIT_SLAVE_0');
+INSERT INTO `ds_1_slave_0`.`t_order_0` VALUES (1106, 11, 'INIT_SLAVE_0');
+INSERT INTO `ds_1_slave_0`.`t_order_0` VALUES (1108, 11, 'INIT_SLAVE_0');
+INSERT INTO `ds_1_slave_0`.`t_order_item_0` VALUES (110001, 1100, 11);
+INSERT INTO `ds_1_slave_0`.`t_order_item_0` VALUES (110201, 1102, 11);
+INSERT INTO `ds_1_slave_0`.`t_order_item_0` VALUES (110401, 1104, 11);
+INSERT INTO `ds_1_slave_0`.`t_order_item_0` VALUES (110601, 1106, 11);
+INSERT INTO `ds_1_slave_0`.`t_order_item_0` VALUES (110801, 1108, 11);
+
+INSERT INTO `ds_1_slave_0`.`t_order_1` VALUES (1101, 11, 'INIT_SLAVE_0');
+INSERT INTO `ds_1_slave_0`.`t_order_1` VALUES (1103, 11, 'INIT_SLAVE_0');
+INSERT INTO `ds_1_slave_0`.`t_order_1` VALUES (1105, 11, 'INIT_SLAVE_0');
+INSERT INTO `ds_1_slave_0`.`t_order_1` VALUES (1107, 11, 'INIT_SLAVE_0');
+INSERT INTO `ds_1_slave_0`.`t_order_1` VALUES (1109, 11, 'INIT_SLAVE_0');
+INSERT INTO `ds_1_slave_0`.`t_order_item_1` VALUES (110101, 1101, 11);
+INSERT INTO `ds_1_slave_0`.`t_order_item_1` VALUES (110301, 1103, 11);
+INSERT INTO `ds_1_slave_0`.`t_order_item_1` VALUES (110501, 1105, 11);
+INSERT INTO `ds_1_slave_0`.`t_order_item_1` VALUES (110701, 1107, 11);
+INSERT INTO `ds_1_slave_0`.`t_order_item_1` VALUES (110901, 1109, 11);
+
+CREATE SCHEMA IF NOT EXISTS `ds_0_slave_1`;
+CREATE SCHEMA IF NOT EXISTS `ds_1_slave_1`;
+
+CREATE TABLE IF NOT EXISTS `ds_0_slave_1`.`t_order_0` (`order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(50), PRIMARY KEY (`order_id`));
+CREATE TABLE IF NOT EXISTS `ds_0_slave_1`.`t_order_1` (`order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(50), PRIMARY KEY (`order_id`));
+CREATE TABLE IF NOT EXISTS `ds_0_slave_1`.`t_order_item_0` (`item_id` INT NOT NULL, `order_id` INT NOT NULL, `user_id` INT NOT NULL, PRIMARY KEY (`item_id`));
+CREATE TABLE IF NOT EXISTS `ds_0_slave_1`.`t_order_item_1` (`item_id` INT NOT NULL, `order_id` INT NOT NULL, `user_id` INT NOT NULL, PRIMARY KEY (`item_id`));
+
+CREATE TABLE IF NOT EXISTS `ds_1_slave_1`.`t_order_0` (`order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(50), PRIMARY KEY (`order_id`));
+CREATE TABLE IF NOT EXISTS `ds_1_slave_1`.`t_order_1` (`order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(50), PRIMARY KEY (`order_id`));
+CREATE TABLE IF NOT EXISTS `ds_1_slave_1`.`t_order_item_0` (`item_id` INT NOT NULL, `order_id` INT NOT NULL, `user_id` INT NOT NULL, PRIMARY KEY (`item_id`));
+CREATE TABLE IF NOT EXISTS `ds_1_slave_1`.`t_order_item_1` (`item_id` INT NOT NULL, `order_id` INT NOT NULL, `user_id` INT NOT NULL, PRIMARY KEY (`item_id`));
+
+INSERT INTO `ds_0_slave_1`.`t_order_0` VALUES (1000, 10, 'INIT_SLAVE_1');
+INSERT INTO `ds_0_slave_1`.`t_order_0` VALUES (1002, 10, 'INIT_SLAVE_1');
+INSERT INTO `ds_0_slave_1`.`t_order_0` VALUES (1004, 10, 'INIT_SLAVE_1');
+INSERT INTO `ds_0_slave_1`.`t_order_0` VALUES (1006, 10, 'INIT_SLAVE_1');
+INSERT INTO `ds_0_slave_1`.`t_order_0` VALUES (1008, 10, 'INIT_SLAVE_1');
+INSERT INTO `ds_0_slave_1`.`t_order_item_0` VALUES (100001, 1000, 10);
+INSERT INTO `ds_0_slave_1`.`t_order_item_0` VALUES (100201, 1002, 10);
+INSERT INTO `ds_0_slave_1`.`t_order_item_0` VALUES (100401, 1004, 10);
+INSERT INTO `ds_0_slave_1`.`t_order_item_0` VALUES (100601, 1006, 10);
+INSERT INTO `ds_0_slave_1`.`t_order_item_0` VALUES (100801, 1008, 10);
+
+INSERT INTO `ds_0_slave_1`.`t_order_1` VALUES (1001, 10, 'INIT_SLAVE_1');
+INSERT INTO `ds_0_slave_1`.`t_order_1` VALUES (1003, 10, 'INIT_SLAVE_1');
+INSERT INTO `ds_0_slave_1`.`t_order_1` VALUES (1005, 10, 'INIT_SLAVE_1');
+INSERT INTO `ds_0_slave_1`.`t_order_1` VALUES (1007, 10, 'INIT_SLAVE_1');
+INSERT INTO `ds_0_slave_1`.`t_order_1` VALUES (1009, 10, 'INIT_SLAVE_1');
+INSERT INTO `ds_0_slave_1`.`t_order_item_1` VALUES (100101, 1001, 10);
+INSERT INTO `ds_0_slave_1`.`t_order_item_1` VALUES (100301, 1003, 10);
+INSERT INTO `ds_0_slave_1`.`t_order_item_1` VALUES (100501, 1005, 10);
+INSERT INTO `ds_0_slave_1`.`t_order_item_1` VALUES (100701, 1007, 10);
+INSERT INTO `ds_0_slave_1`.`t_order_item_1` VALUES (100901, 1009, 10);
+
+INSERT INTO `ds_1_slave_1`.`t_order_0` VALUES (1100, 11, 'INIT_SLAVE_1');
+INSERT INTO `ds_1_slave_1`.`t_order_0` VALUES (1102, 11, 'INIT_SLAVE_1');
+INSERT INTO `ds_1_slave_1`.`t_order_0` VALUES (1104, 11, 'INIT_SLAVE_1');
+INSERT INTO `ds_1_slave_1`.`t_order_0` VALUES (1106, 11, 'INIT_SLAVE_1');
+INSERT INTO `ds_1_slave_1`.`t_order_0` VALUES (1108, 11, 'INIT_SLAVE_1');
+INSERT INTO `ds_1_slave_1`.`t_order_item_0` VALUES (110001, 1100, 11);
+INSERT INTO `ds_1_slave_1`.`t_order_item_0` VALUES (110201, 1102, 11);
+INSERT INTO `ds_1_slave_1`.`t_order_item_0` VALUES (110401, 1104, 11);
+INSERT INTO `ds_1_slave_1`.`t_order_item_0` VALUES (110601, 1106, 11);
+INSERT INTO `ds_1_slave_1`.`t_order_item_0` VALUES (110801, 1108, 11);
+
+INSERT INTO `ds_1_slave_1`.`t_order_1` VALUES (1101, 11, 'INIT_SLAVE_1');
+INSERT INTO `ds_1_slave_1`.`t_order_1` VALUES (1103, 11, 'INIT_SLAVE_1');
+INSERT INTO `ds_1_slave_1`.`t_order_1` VALUES (1105, 11, 'INIT_SLAVE_1');
+INSERT INTO `ds_1_slave_1`.`t_order_1` VALUES (1107, 11, 'INIT_SLAVE_1');
+INSERT INTO `ds_1_slave_1`.`t_order_1` VALUES (1109, 11, 'INIT_SLAVE_1');
+INSERT INTO `ds_1_slave_1`.`t_order_item_1` VALUES (110101, 1101, 11);
+INSERT INTO `ds_1_slave_1`.`t_order_item_1` VALUES (110301, 1103, 11);
+INSERT INTO `ds_1_slave_1`.`t_order_item_1` VALUES (110501, 1105, 11);
+INSERT INTO `ds_1_slave_1`.`t_order_item_1` VALUES (110701, 1107, 11);
+INSERT INTO `ds_1_slave_1`.`t_order_item_1` VALUES (110901, 1109, 11);

sharding-jdbc-example/sharding-jdbc-example-jdbc-masterslave/src/main/resources/logback.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+
+    <property name="log.context.name" value="sharding-jdbc-example-jdbc" />
+    <property name="log.charset" value="UTF-8" />
+    <property name="log.pattern" value="[%-5level] %date --%thread-- [%logger] %msg %n" />
+
+    <contextName>${log.context.name}</contextName>
+
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder charset="${log.charset}">
+            <pattern>${log.pattern}</pattern>
+        </encoder>
+    </appender>
+
+    <root>
+        <level value="INFO" />
+        <appender-ref ref="STDOUT" />
+    </root>
+</configuration>

sharding-jdbc-example/sharding-jdbc-example-spring-masterslave/pom.xml

+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>sharding-jdbc-example</artifactId>
+        <groupId>com.dangdang</groupId>
+        <version>1.2.2-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>sharding-jdbc-example-spring-masterslave</artifactId>
+</project>
\ No newline at end of file

sharding-jdbc-example/sharding-jdbc-example-spring-masterslave/src/main/java/com/dangdang/ddframe/rdb/sharding/example/config/spring/masterslave/SpringNamespaceWithMasterSlaveMain.java

+/*
+ * Copyright 1999-2015 dangdang.com.
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * </p>
+ */
+
+package com.dangdang.ddframe.rdb.sharding.example.config.spring.masterslave;
+
+import com.dangdang.ddframe.rdb.sharding.example.config.spring.masterslave.service.OrderService;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.support.ClassPathXmlApplicationContext;
+
+import java.sql.SQLException;
+
+public final class SpringNamespaceWithMasterSlaveMain {
+    
+    // CHECKSTYLE:OFF
+    public static void main(final String[] args) throws SQLException {
+    // CHECKSTYLE:ON
+        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("META-INF/applicationContextWithMasterSlave.xml");
+        OrderService orderService =  applicationContext.getBean(OrderService.class);
+        orderService.insert();
+        orderService.select();
+        orderService.delete();
+        orderService.select();
+    }
+}

sharding-jdbc-example/sharding-jdbc-example-spring-masterslave/src/main/java/com/dangdang/ddframe/rdb/sharding/example/config/spring/masterslave/algorithm/SingleKeyModuloTableShardingAlgorithm.java

+
+/*
+ * Copyright 1999-2015 dangdang.com.
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * </p>
+ */
+
+package com.dangdang.ddframe.rdb.sharding.example.config.spring.masterslave.algorithm;
+
+import com.dangdang.ddframe.rdb.sharding.api.ShardingValue;
+import com.dangdang.ddframe.rdb.sharding.api.strategy.table.SingleKeyTableShardingAlgorithm;
+import com.google.common.collect.Range;
+
+import java.util.Collection;
+import java.util.LinkedHashSet;
+
+public class SingleKeyModuloTableShardingAlgorithm implements SingleKeyTableShardingAlgorithm<Integer> {
+    
+    @Override
+    public String doEqualSharding(final Collection<String> availableTargetNames, final ShardingValue<Integer> shardingValue) {
+        for (String each : availableTargetNames) {
+            if (each.endsWith(shardingValue.getValue() % 4 + "")) {
+                return each;
+            }
+        }
+        throw new UnsupportedOperationException();
+    }
+    
+    @Override
+    public Collection<String> doInSharding(final Collection<String> availableTargetNames, final ShardingValue<Integer> shardingValue) {
+        Collection<String> result = new LinkedHashSet<>(availableTargetNames.size());
+        Collection<Integer> values = shardingValue.getValues();
+        for (Integer value : values) {
+            for (String tableNames : availableTargetNames) {
+                if (tableNames.endsWith(value % 4 + "")) {
+                    result.add(tableNames);
+                }
+            }
+        }
+        return result;
+    }
+    
+    @Override
+    public Collection<String> doBetweenSharding(final Collection<String> availableTargetNames, final ShardingValue<Integer> shardingValue) {
+        Collection<String> result = new LinkedHashSet<>(availableTargetNames.size());
+        Range<Integer> range = shardingValue.getValueRange();
+        for (Integer i = range.lowerEndpoint(); i <= range.upperEndpoint(); i++) {
+            for (String each : availableTargetNames) {
+                if (each.endsWith(i % 4 + "")) {
+                    result.add(each);
+                }
+            }
+        }
+        return result;
+    }
+}

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

+/*
+ * Copyright 1999-2015 dangdang.com.
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * </p>
+ */
+
+package com.dangdang.ddframe.rdb.sharding.example.config.spring.masterslave.repository;
+
+public interface ConfigRepository {
+    
+    void select();
+}

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

+/*
+ * Copyright 1999-2015 dangdang.com.
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * </p>
+ */
+
+package com.dangdang.ddframe.rdb.sharding.example.config.spring.masterslave.repository;
+
+import com.dangdang.ddframe.rdb.sharding.spring.datasource.SpringShardingDataSource;
+import org.springframework.stereotype.Repository;
+
+import javax.annotation.Resource;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+
+@Repository
+public class ConfigRepositoryImpl implements ConfigRepository {
+    
+    @Resource
+    private SpringShardingDataSource shardingDataSource;
+    
+    @Override
+    public void select() {
+        String sql = "SELECT c.* FROM t_config c";
+        try (
+            Connection conn = shardingDataSource.getConnection();
+            PreparedStatement preparedStatement = conn.prepareStatement(sql)) {
+            try (ResultSet rs = preparedStatement.executeQuery()) {
+                while (rs.next()) {
+                    System.out.println("configName:" + rs.getString(2) + ",configValue:" + rs.getString(3));
+                }
+            }
+        // CHECKSTYLE:OFF
+        } catch (final Exception ex) {
+        // CHECKSTYLE:ON
+            ex.printStackTrace();
+        }
+    }
+}

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

+/*
+ * Copyright 1999-2015 dangdang.com.
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * </p>
+ */
+
+package com.dangdang.ddframe.rdb.sharding.example.config.spring.masterslave.repository;
+
+public interface OrderRepository {
+    
+    void insert();
+    
+    void delete();
+    
+    void select();
+}

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

+/*
+ * Copyright 1999-2015 dangdang.com.
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * </p>
+ */
+
+package com.dangdang.ddframe.rdb.sharding.example.config.spring.masterslave.repository;
+
+import com.dangdang.ddframe.rdb.sharding.spring.datasource.SpringShardingDataSource;
+import org.springframework.stereotype.Repository;
+
+import javax.annotation.Resource;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+
+@Repository
+public class OrderRepositoryImpl implements OrderRepository {
+    
+    @Resource
+    private SpringShardingDataSource shardingDataSource;
+    
+    @Override
+    public void insert() {
+        String orderSql = "INSERT INTO `t_order` (`order_id`, `user_id`, `status`) VALUES (?, ?, ?)";
+        String orderItemSql = "INSERT INTO `t_order_item` (`order_item_id`, `order_id`, `user_id`, `status`) VALUES (?, ?, ?, ?)";
+        for (int orderId = 1; orderId <= 4; orderId++) {
+            for (int userId = 1; userId <= 2; userId++) {
+                try (Connection connection = shardingDataSource.getConnection()) {
+                    PreparedStatement preparedStatement = connection.prepareStatement(orderSql);
+                    preparedStatement.setInt(1, orderId);
+                    preparedStatement.setInt(2, userId);
+                    preparedStatement.setString(3, "insert");
+                    preparedStatement.execute();
+                    preparedStatement.close();
+                
+                    preparedStatement = connection.prepareStatement(orderItemSql);
+                    int orderItemId = orderId + 4;
+                    preparedStatement.setInt(1, orderItemId);
+                    preparedStatement.setInt(2, orderId);
+                    preparedStatement.setInt(3, userId);
+                    preparedStatement.setString(4, "insert");
+                    preparedStatement.execute();
+                    preparedStatement.close();
+                // CHECKSTYLE:OFF
+                } catch (final Exception ex) {
+                // CHECKSTYLE:ON
+                    ex.printStackTrace();
+                }
+            }
+        }
+    }
+    
+    @Override
+    public void delete() {
+        String orderSql = "DELETE FROM `t_order`";
+        String orderItemSql = "DELETE FROM `t_order_item`";
+        try (Connection connection = shardingDataSource.getConnection()) {
+            PreparedStatement preparedStatement = connection.prepareStatement(orderSql);
+            preparedStatement.execute();
+            preparedStatement.close();
+            preparedStatement = connection.prepareStatement(orderItemSql);
+            preparedStatement.execute();
+            preparedStatement.close();
+        // CHECKSTYLE:OFF
+        } catch (final Exception ex) {
+        // CHECKSTYLE:ON
+            ex.printStackTrace();
+        }
+    }
+    
+    @Override
+    public void select() {
+        String sql = "SELECT i.* FROM t_order o JOIN t_order_item i ON o.order_id=i.order_id WHERE o.user_id=? AND o.order_id=?";
+        try (
+            Connection conn = shardingDataSource.getConnection();
+            PreparedStatement preparedStatement = conn.prepareStatement(sql)) {
+            preparedStatement.setInt(1, 1);
+            preparedStatement.setInt(2, 2);
+            try (ResultSet rs = preparedStatement.executeQuery()) {
+                while (rs.next()) {
+                    System.out.println("orderItemId:" + rs.getInt(1) + ",orderId:" + rs.getInt(2) 
+                        + ",userId:" + rs.getInt(3) + ",status:" + rs.getString(4));
+                }
+            }
+        // CHECKSTYLE:OFF
+        } catch (final Exception ex) {
+        // CHECKSTYLE:ON
+            ex.printStackTrace();
+        }
+    }
+}

sharding-jdbc-example/sharding-jdbc-example-spring-masterslave/src/main/java/com/dangdang/ddframe/rdb/sharding/example/config/spring/masterslave/service/ConfigService.java

+/*
+ * Copyright 1999-2015 dangdang.com.
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * </p>
+ */
+
+package com.dangdang.ddframe.rdb.sharding.example.config.spring.masterslave.service;
+
+public interface ConfigService {
+    
+    void select();
+}

sharding-jdbc-example/sharding-jdbc-example-spring-masterslave/src/main/java/com/dangdang/ddframe/rdb/sharding/example/config/spring/masterslave/service/ConfigServiceImpl.java

+/*
+ * Copyright 1999-2015 dangdang.com.
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * </p>
+ */
+
+package com.dangdang.ddframe.rdb.sharding.example.config.spring.masterslave.service;
+
+import com.dangdang.ddframe.rdb.sharding.example.config.spring.masterslave.repository.ConfigRepository;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+
+@Service
+public class ConfigServiceImpl implements ConfigService {
+    
+    @Resource
+    private ConfigRepository configRepository;
+    
+    @Override
+    public void select() {
+        configRepository.select();
+    }
+}

sharding-jdbc-example/sharding-jdbc-example-spring-masterslave/src/main/java/com/dangdang/ddframe/rdb/sharding/example/config/spring/masterslave/service/OrderService.java

+/*
+ * Copyright 1999-2015 dangdang.com.
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * </p>
+ */
+
+package com.dangdang.ddframe.rdb.sharding.example.config.spring.masterslave.service;
+
+public interface OrderService {
+    
+    void insert();
+    
+    void delete();
+    
+    void select();
+}

sharding-jdbc-example/sharding-jdbc-example-spring-masterslave/src/main/java/com/dangdang/ddframe/rdb/sharding/example/config/spring/masterslave/service/OrderServiceImpl.java

+/*
+ * Copyright 1999-2015 dangdang.com.
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * </p>
+ */
+
+package com.dangdang.ddframe.rdb.sharding.example.config.spring.masterslave.service;
+
+import com.dangdang.ddframe.rdb.sharding.example.config.spring.masterslave.repository.OrderRepository;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+
+@Service
+public class OrderServiceImpl implements OrderService {
+    
+    @Resource
+    private OrderRepository orderRepository;
+    
+    @Override
+    public void insert() {
+        try {
+            orderRepository.insert();
+        // CHECKSTYLE:OFF
+        } catch (final Exception ex) {
+        // CHECKSTYLE:ON
+            ex.printStackTrace();
+        }
+    }
+    
+    @Override
+    public void delete() {
+        orderRepository.delete();
+    }
+    
+    @Override
+    public void select() {
+        orderRepository.select();
+    }
+}

sharding-jdbc-example/sharding-jdbc-example-spring-masterslave/src/main/resources/META-INF/applicationContextWithMasterSlave.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
+    xmlns:context="http://www.springframework.org/schema/context"
+    xmlns:rdb="http://www.dangdang.com/schema/ddframe/rdb" 
+    xsi:schemaLocation="http://www.springframework.org/schema/beans 
+                        http://www.springframework.org/schema/beans/spring-beans.xsd
+                        http://www.springframework.org/schema/context 
+                        http://www.springframework.org/schema/context/spring-context.xsd 
+                        http://www.dangdang.com/schema/ddframe/rdb 
+                        http://www.dangdang.com/schema/ddframe/rdb/rdb.xsd 
+                        ">
+    <context:component-scan base-package="com.dangdang.ddframe.rdb.sharding.example.config.spring"/>
+    
+    <bean id="dbtbl_0_master" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
+        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
+        <property name="url" value="jdbc:mysql://localhost:3306/dbtbl_0_master"/>
+        <property name="username" value="root"/>
+        <property name="password" value=""/>
+    </bean>
+    
+    <bean id="dbtbl_0_slave_0" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
+        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
+        <property name="url" value="jdbc:mysql://localhost:3306/dbtbl_0_slave_0"/>
+        <property name="username" value="root"/>
+        <property name="password" value=""/>
+    </bean>
+    
+    <bean id="dbtbl_0_slave_1" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
+        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
+        <property name="url" value="jdbc:mysql://localhost:3306/dbtbl_0_slave_1"/>
+        <property name="username" value="root"/>
+        <property name="password" value=""/>
+    </bean>
+    
+    <bean id="dbtbl_1_master" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
+        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
+        <property name="url" value="jdbc:mysql://localhost:3306/dbtbl_1_master"/>
+        <property name="username" value="root"/>
+        <property name="password" value=""/>
+    </bean>
+    
+    <bean id="dbtbl_1_slave_0" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
+        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
+        <property name="url" value="jdbc:mysql://localhost:3306/dbtbl_1_slave_0"/>
+        <property name="username" value="root"/>
+        <property name="password" value=""/>
+    </bean>
+    
+    <bean id="dbtbl_1_slave_1" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
+        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
+        <property name="url" value="jdbc:mysql://localhost:3306/dbtbl_1_slave_1"/>
+        <property name="username" value="root"/>
+        <property name="password" value=""/>
+    </bean>
+    
+    <rdb:master-slave-data-source id="dbtbl_0" master-data-source-ref="dbtbl_0_master" slave-data-sources-ref="dbtbl_0_slave_0, dbtbl_0_slave_1" />
+    <rdb:master-slave-data-source id="dbtbl_1" master-data-source-ref="dbtbl_1_master" slave-data-sources-ref="dbtbl_1_slave_0, dbtbl_1_slave_1" />
+    
+    <rdb:strategy id="databaseStrategy" sharding-columns="user_id" algorithm-expression="dbtbl_${user_id.longValue() % 2}"/>
+    
+    <rdb:strategy id="orderTableStrategy" sharding-columns="order_id" algorithm-expression="t_order_${order_id.longValue() % 4}"/>
+    
+    <rdb:strategy id="orderItemTableStrategy" sharding-columns="order_id" algorithm-class="com.dangdang.ddframe.rdb.sharding.example.config.spring.masterslave.algorithm.SingleKeyModuloTableShardingAlgorithm"/>
+    
+    <rdb:data-source id="shardingDataSource">
+        <rdb:sharding-rule data-sources="dbtbl_0,dbtbl_1">
+            <rdb:table-rules>
+                <rdb:table-rule logic-table="t_order" actual-tables="t_order_${0..3}" database-strategy="databaseStrategy" table-strategy="orderTableStrategy"/>
+                <rdb:table-rule logic-table="t_order_item" actual-tables="t_order_item_0,t_order_item_1,t_order_item_2,t_order_item_3" database-strategy="databaseStrategy" table-strategy="orderItemTableStrategy"/>
+            </rdb:table-rules>
+        </rdb:sharding-rule>
+        <rdb:props>
+            <prop key="metrics.enable">false</prop>
+        </rdb:props>
+    </rdb:data-source>
+</beans>

sharding-jdbc-example/sharding-jdbc-example-spring-masterslave/src/main/resources/all_schema.sql

+CREATE SCHEMA IF NOT EXISTS `dbtbl_0_master`;
+CREATE SCHEMA IF NOT EXISTS `dbtbl_1_master`;
+
+CREATE TABLE IF NOT EXISTS `dbtbl_0_master`.`t_order_0` (`order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_0_master`.`t_order_1` (`order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_0_master`.`t_order_2` (`order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_0_master`.`t_order_3` (`order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_0_master`.`t_order_item_0` (`order_item_id` INT NOT NULL, `order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_item_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_0_master`.`t_order_item_1` (`order_item_id` INT NOT NULL, `order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_item_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_0_master`.`t_order_item_2` (`order_item_id` INT NOT NULL, `order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_item_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_0_master`.`t_order_item_3` (`order_item_id` INT NOT NULL, `order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_item_id`));
+
+CREATE TABLE IF NOT EXISTS `dbtbl_1_master`.`t_order_0` (`order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_1_master`.`t_order_1` (`order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_1_master`.`t_order_2` (`order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_1_master`.`t_order_3` (`order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_1_master`.`t_order_item_0` (`order_item_id` INT NOT NULL, `order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_item_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_1_master`.`t_order_item_1` (`order_item_id` INT NOT NULL, `order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_item_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_1_master`.`t_order_item_2` (`order_item_id` INT NOT NULL, `order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_item_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_1_master`.`t_order_item_3` (`order_item_id` INT NOT NULL, `order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_item_id`));
+
+CREATE SCHEMA IF NOT EXISTS `dbtbl_0_slave_0`;
+CREATE SCHEMA IF NOT EXISTS `dbtbl_1_slave_0`;
+
+CREATE TABLE IF NOT EXISTS `dbtbl_0_slave_0`.`t_order_0` (`order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_0_slave_0`.`t_order_1` (`order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_0_slave_0`.`t_order_2` (`order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_0_slave_0`.`t_order_3` (`order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_0_slave_0`.`t_order_item_0` (`order_item_id` INT NOT NULL, `order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_item_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_0_slave_0`.`t_order_item_1` (`order_item_id` INT NOT NULL, `order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_item_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_0_slave_0`.`t_order_item_2` (`order_item_id` INT NOT NULL, `order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_item_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_0_slave_0`.`t_order_item_3` (`order_item_id` INT NOT NULL, `order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_item_id`));
+
+CREATE TABLE IF NOT EXISTS `dbtbl_1_slave_0`.`t_order_0` (`order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_1_slave_0`.`t_order_1` (`order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_1_slave_0`.`t_order_2` (`order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_1_slave_0`.`t_order_3` (`order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_1_slave_0`.`t_order_item_0` (`order_item_id` INT NOT NULL, `order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_item_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_1_slave_0`.`t_order_item_1` (`order_item_id` INT NOT NULL, `order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_item_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_1_slave_0`.`t_order_item_2` (`order_item_id` INT NOT NULL, `order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_item_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_1_slave_0`.`t_order_item_3` (`order_item_id` INT NOT NULL, `order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_item_id`));
+
+CREATE SCHEMA IF NOT EXISTS `dbtbl_0_slave_1`;
+CREATE SCHEMA IF NOT EXISTS `dbtbl_1_slave_1`;
+
+CREATE TABLE IF NOT EXISTS `dbtbl_0_slave_1`.`t_order_0` (`order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_0_slave_1`.`t_order_1` (`order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_0_slave_1`.`t_order_2` (`order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_0_slave_1`.`t_order_3` (`order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_0_slave_1`.`t_order_item_0` (`order_item_id` INT NOT NULL, `order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_item_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_0_slave_1`.`t_order_item_1` (`order_item_id` INT NOT NULL, `order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_item_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_0_slave_1`.`t_order_item_2` (`order_item_id` INT NOT NULL, `order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_item_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_0_slave_1`.`t_order_item_3` (`order_item_id` INT NOT NULL, `order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_item_id`));
+
+CREATE TABLE IF NOT EXISTS `dbtbl_1_slave_1`.`t_order_0` (`order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_1_slave_1`.`t_order_1` (`order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_1_slave_1`.`t_order_2` (`order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_1_slave_1`.`t_order_3` (`order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_1_slave_1`.`t_order_item_0` (`order_item_id` INT NOT NULL, `order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_item_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_1_slave_1`.`t_order_item_1` (`order_item_id` INT NOT NULL, `order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_item_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_1_slave_1`.`t_order_item_2` (`order_item_id` INT NOT NULL, `order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_item_id`));
+CREATE TABLE IF NOT EXISTS `dbtbl_1_slave_1`.`t_order_item_3` (`order_item_id` INT NOT NULL, `order_id` INT NOT NULL, `user_id` INT NOT NULL, `status` VARCHAR(10) NULL, PRIMARY KEY (`order_item_id`));

sharding-jdbc-example/sharding-jdbc-example-spring-masterslave/src/main/resources/logback.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+
+    <property name="log.context.name" value="sharding-jdbc-example-config-spring" />
+    <property name="log.charset" value="UTF-8" />
+    <property name="log.pattern" value="[%-5level] %date --%thread-- [%logger] %msg %n" />
+
+    <contextName>${log.context.name}</contextName>
+
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder charset="${log.charset}">
+            <pattern>${log.pattern}</pattern>
+        </encoder>
+    </appender>
+
+    <root>
+        <level value="INFO" />
+        <appender-ref ref="STDOUT" />
+    </root>
+</configuration>