数据分片

    基于Java编码的规则配置

    2.     Map<String, DataSource> dataSourceMap = new HashMap<>();
    4.     // 配置第一个数据源
    5.     BasicDataSource dataSource1 = new BasicDataSource();
    6.     dataSource1.setDriverClassName("com.mysql.jdbc.Driver");
    7.     dataSource1.setUrl("jdbc:mysql://localhost:3306/ds0");
    8.     dataSource1.setUsername("root");
    9.     dataSource1.setPassword("");
    10.     dataSourceMap.put("ds0", dataSource1);
    12.     // 配置第二个数据源
    13.     BasicDataSource dataSource2 = new BasicDataSource();
    14.     dataSource2.setDriverClassName("com.mysql.jdbc.Driver");
    15.     dataSource2.setUrl("jdbc:mysql://localhost:3306/ds1");
    16.     dataSource2.setUsername("root");
    17.     dataSource2.setPassword("");
    18.     dataSourceMap.put("ds1", dataSource2);
    20.     // 配置Order表规则
    21.     TableRuleConfiguration orderTableRuleConfig = new TableRuleConfiguration("t_order","ds${0..1}.t_order${0..1}");
    23.     // 配置分库 + 分表策略
    24.     orderTableRuleConfig.setDatabaseShardingStrategyConfig(new InlineShardingStrategyConfiguration("user_id", "ds${user_id % 2}"));
    25.     orderTableRuleConfig.setTableShardingStrategyConfig(new InlineShardingStrategyConfiguration("order_id", "t_order${order_id % 2}"));
    27.     // 配置分片规则
    28.     ShardingRuleConfiguration shardingRuleConfig = new ShardingRuleConfiguration();
    29.     shardingRuleConfig.getTableRuleConfigs().add(orderTableRuleConfig);
    31.     // 省略配置order_item表规则...
    32.     // ...
    34.     // 获取数据源对象
    35.     DataSource dataSource = ShardingDataSourceFactory.createDataSource(dataSourceMap, shardingRuleConfig, new Properties());

    或通过Yaml方式配置，与以上配置等价：

    1. dataSources:
    2.   ds0: !!org.apache.commons.dbcp.BasicDataSource
    3.     driverClassName: com.mysql.jdbc.Driver
    4.     url: jdbc:mysql://localhost:3306/ds0
    5.     username: root
    6.   ds1: !!org.apache.commons.dbcp.BasicDataSource
    7.     driverClassName: com.mysql.jdbc.Driver
    8.     url: jdbc:mysql://localhost:3306/ds1
    9.     username: root
    10.     password: 
    12. shardingRule:
    13.   tables:
    15.       actualDataNodes: ds${0..1}.t_order${0..1}
    16.       databaseStrategy: 
    17.         inline:
    18.           shardingColumn: user_id
    19.           algorithmExpression: ds${user_id % 2}
    20.       tableStrategy: 
    21.         inline:
    22.           shardingColumn: order_id
    23.           algorithmExpression: t_order${order_id % 2}
    24.     t_order_item: 
    25.       actualDataNodes: ds${0..1}.t_order_item${0..1}
    26.       databaseStrategy: 
    27.         inline:
    28.           shardingColumn: user_id
    29.           algorithmExpression: ds${user_id % 2}
    30.       tableStrategy: 
    31.         inline:
    32.           shardingColumn: order_id
    33.           algorithmExpression: t_order_item${order_id % 2}

    使用原生JDBC

    1. DataSource dataSource = YamlShardingDataSourceFactory.createDataSource(yamlFile);
    2. 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=?";
    3. try (
    4.         Connection conn = dataSource.getConnection();
    5.         PreparedStatement preparedStatement = conn.prepareStatement(sql)) {
    6.     preparedStatement.setInt(1, 10);
    7.     preparedStatement.setInt(2, 1001);
    8.     try (ResultSet rs = preparedStatement.executeQuery()) {
    9.         while(rs.next()) {
    10.             System.out.println(rs.getInt(1));
    11.             System.out.println(rs.getInt(2));
    12.         }
    13.     }
    14. }

    使用Spring

    1. <!-- for spring boot -->
    2. <dependency>
    3.     <groupId>org.apache.shardingsphere</groupId>
    4.     <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
    5.     <version>${sharding-sphere.version}</version>
    6. </dependency>
    8. <!-- for spring namespace -->
    9. <dependency>
    10.     <artifactId>sharding-jdbc-spring-namespace</artifactId>
    11.     <version>${sharding-sphere.version}</version>
    12. </dependency>

    基于Spring boot的规则配置

    基于Spring boot + JNDI的规则配置

    如果您计划使用Spring boot + JNDI的方式，在应用容器（如Tomcat）中使用Sharding-JDBC时，可使用spring.shardingsphere.datasource.${datasourceName}.jndiName来代替数据源的一系列配置。 如：

    3. spring.shardingsphere.datasource.ds0.jndi-name=java:comp/env/jdbc/ds0
    4. spring.shardingsphere.datasource.ds1.jndi-name=jdbc/ds1
    6. spring.shardingsphere.sharding.default-database-strategy.inline.sharding-column=user_id
    7. spring.shardingsphere.sharding.default-database-strategy.inline.algorithm-expression=ds$->{user_id % 2}
    9. spring.shardingsphere.sharding.tables.t_order.actual-data-nodes=ds$->{0..1}.t_order$->{0..1}
    10. spring.shardingsphere.sharding.tables.t_order.table-strategy.inline.sharding-column=order_id
    11. spring.shardingsphere.sharding.tables.t_order.table-strategy.inline.algorithm-expression=t_order$->{order_id % 2}
    13. spring.shardingsphere.sharding.tables.t_order_item.actual-data-nodes=ds$->{0..1}.t_order_item$->{0..1}
    14. spring.shardingsphere.sharding.tables.t_order_item.table-strategy.inline.sharding-column=order_id
    15. spring.shardingsphere.sharding.tables.t_order_item.table-strategy.inline.algorithm-expression=t_order_item$->{order_id % 2}
    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    4.     xmlns:sharding="http://shardingsphere.apache.org/schema/shardingsphere/sharding" 
    5.     xsi:schemaLocation="http://www.springframework.org/schema/beans 
    6.                         http://www.springframework.org/schema/beans/spring-beans.xsd
    7.                         http://shardingsphere.apache.org/schema/shardingsphere/sharding 
    8.                         http://shardingsphere.apache.org/schema/shardingsphere/sharding/sharding.xsd 
    9.                         ">
    10.     <bean id="ds0" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
    11.         <property name="driverClassName" value="com.mysql.jdbc.Driver" />
    12.         <property name="url" value="jdbc:mysql://localhost:3306/ds0" />
    13.         <property name="username" value="root" />
    14.         <property name="password" value="" />
    15.     </bean>
    16.     <bean id="ds1" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
    17.         <property name="driverClassName" value="com.mysql.jdbc.Driver" />
    18.         <property name="url" value="jdbc:mysql://localhost:3306/ds1" />
    19.         <property name="username" value="root" />
    20.         <property name="password" value="" />
    21.     </bean>
    23.     <sharding:inline-strategy id="databaseStrategy" sharding-column="user_id" algorithm-expression="ds$->{user_id % 2}" />
    24.     <sharding:inline-strategy id="orderTableStrategy" sharding-column="order_id" algorithm-expression="t_order$->{order_id % 2}" />
    25.     <sharding:inline-strategy id="orderItemTableStrategy" sharding-column="order_id" algorithm-expression="t_order_item$->{order_id % 2}" />
    27.     <sharding:data-source id="shardingDataSource">
    28.         <sharding:sharding-rule data-source-names="ds0,ds1">
    29.             <sharding:table-rules>
    30.                 <sharding:table-rule logic-table="t_order" actual-data-nodes="ds$->{0..1}.t_order$->{0..1}" database-strategy-ref="databaseStrategy" table-strategy-ref="orderTableStrategy" />
    31.                 <sharding:table-rule logic-table="t_order_item" actual-data-nodes="ds$->{0..1}.t_order_item$->{0..1}" database-strategy-ref="databaseStrategy" table-strategy-ref="orderItemTableStrategy" />
    32.             </sharding:table-rules>
    33.         </sharding:sharding-rule>

    在Spring中使用DataSource

    规则配置包括数据源配置、表规则配置、分库策略和分表策略组成。这只是最简单的配置方式，实际使用可更加灵活，如：多分片键，分片策略直接和表规则配置绑定等。更多的详细配置请参考配置手册。