<dependency>
    <groupId>org.apache.shardingsphere</groupId>
    <artifactId>shardingsphere-jdbc-core-spring-boot-starter</artifactId>
    <version>5.1.2</version>
</dependency>

spring:
  shardingsphere:
    datasource:
      names: ds0,ds1,ds2,ds3
      ds0:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        jdbc-url: jdbc:mysql://localhost:3306/order_db_0
        username: root
        password: password
      # 其他數(shù)據(jù)源配置...
    rules:
      sharding:
        tables:
          t_order:
            actual-data-nodes: ds${0..3}.t_order
            database-strategy:
              standard:
                sharding-column: order_id
                sharding-algorithm-name: order-id-hash
        sharding-algorithms:
          order-id-hash:
            type: HASH_MOD
            props:
              sharding-count: 4

@Entity
@Table(name = "t_order")
public class Order {
    @Id
    private Long orderId;  // 分片鍵
    private Long userId;
    private BigDecimal amount;
    private String status;
    // getters and setters
}

@Repository
public interface OrderRepository extends JpaRepository<Order, Long> {
    // 查詢方法
}

spring:
  shardingsphere:
    datasource:
      names: ds0,ds1,ds2,ds3
      # 數(shù)據(jù)源配置...
    rules:
      sharding:
        tables:
          t_order:
            actual-data-nodes: ds${0..3}.t_order
            database-strategy:
              standard:
                sharding-column: order_id
                sharding-algorithm-name: order-id-range
        sharding-algorithms:
          order-id-range:
            type: RANGE
            props:
              strategy: standard
              range-lower: 0,1000000,2000000,3000000
              range-upper: 999999,1999999,2999999,3999999

@Component
public class CustomRangeShardingAlgorithm implements StandardShardingAlgorithm<Long> {
    @Override
    public String doSharding(Collection<String> availableTargetNames, PreciseShardingValue<Long> shardingValue) {
        Long orderId = shardingValue.getValue();
        for (String targetName : availableTargetNames) {
            if (targetName.endsWith("0") && orderId <= 1000000) {
                return targetName;
            } else if (targetName.endsWith("1") && orderId > 1000000 && orderId <= 2000000) {
                return targetName;
            } else if (targetName.endsWith("2") && orderId > 2000000 && orderId <= 3000000) {
                return targetName;
            } else if (targetName.endsWith("3") && orderId > 3000000) {
                return targetName;
            }
        }
        throw new UnsupportedOperationException("No available target name for order id: " + orderId);
    }

    // 其他必要的方法實現(xiàn)...
}

spring:
  shardingsphere:
    datasource:
      names: ds0,ds1,ds2,ds3
      # 數(shù)據(jù)源配置...
    rules:
      sharding:
        tables:
          t_order:
            actual-data-nodes: ds${0..3}.t_order
            database-strategy:
              complex:
                sharding-columns: user_id,order_date
                sharding-algorithm-name: complex-algorithm
        sharding-algorithms:
          complex-algorithm:
            type: CLASS_BASED
            props:
              strategy: COMPLEX
              algorithmClassName: com.example.CustomComplexShardingAlgorithm

@Component
public class CustomComplexShardingAlgorithm implements ComplexKeysShardingAlgorithm<Comparable<?>> {
    
    @Override
    public Collection<String> doSharding(Collection<String> availableTargetNames, 
                                        ComplexKeysShardingValue<Comparable<?>> shardingValue) {
        Map<String, Collection<Comparable<?>>> columnNameAndShardingValuesMap = 
            shardingValue.getColumnNameAndShardingValuesMap();
        
        Collection<Comparable<?>> userIds = columnNameAndShardingValuesMap.get("user_id");
        Collection<Comparable<?>> orderDates = columnNameAndShardingValuesMap.get("order_date");
        
        List<String> result = new ArrayList<>();
        
        for (Comparable<?> userId : userIds) {
            for (Comparable<?> orderDate : orderDates) {
                // 使用用戶ID和訂單日期的組合確定分片
                LocalDate date = (LocalDate) orderDate;
                long hash = (long) userId * 31 + date.getYear() * 12 + date.getMonthValue();
                int shardingKey = (int) (hash % 4);  // 分4個片
                
                for (String targetName : availableTargetNames) {
                    if (targetName.endsWith(String.valueOf(shardingKey))) {
                        result.add(targetName);
                    }
                }
            }
        }
        
        return result;
    }
}

@Entity
@Table(name = "t_order")
public class Order {
    @Id
    private Long orderId;
    private Long userId;  // 復(fù)合分片鍵之一
    private LocalDate orderDate;  // 復(fù)合分片鍵之一
    private BigDecimal amount;
    private String status;
    // getters and setters
}

spring:
  shardingsphere:
    datasource:
      names: ds0,ds1,ds2,ds3
      # 數(shù)據(jù)源配置...
    rules:
      sharding:
        tables:
          t_order:
            actual-data-nodes: ds${0..3}.t_order
            database-strategy:
              standard:
                sharding-column: create_time
                sharding-algorithm-name: time-sharding
        sharding-algorithms:
          time-sharding:
            type: INTERVAL
            props:
              datetime-pattern: yyyy-MM-dd HH:mm:ss
              datetime-lower: 2023-01-01 00:00:00
              datetime-upper: 2023-12-31 23:59:59
              sharding-suffix-pattern: yyyyMM
              datetime-interval-amount: 3
              datetime-interval-unit: MONTHS

@Component
public class QuarterlyShardingAlgorithm implements StandardShardingAlgorithm<Date> {
    
    private static final Map<Integer, Integer> QUARTER_MAP = new HashMap<>();
    
    static {
        // 將月份映射到季度
        QUARTER_MAP.put(1, 1);
        QUARTER_MAP.put(2, 1);
        QUARTER_MAP.put(3, 1);
        QUARTER_MAP.put(4, 2);
        QUARTER_MAP.put(5, 2);
        QUARTER_MAP.put(6, 2);
        QUARTER_MAP.put(7, 3);
        QUARTER_MAP.put(8, 3);
        QUARTER_MAP.put(9, 3);
        QUARTER_MAP.put(10, 4);
        QUARTER_MAP.put(11, 4);
        QUARTER_MAP.put(12, 4);
    }
    
    @Override
    public String doSharding(Collection<String> availableTargetNames, PreciseShardingValue<Date> shardingValue) {
        Date date = shardingValue.getValue();
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        int year = calendar.get(Calendar.YEAR);
        int month = calendar.get(Calendar.MONTH) + 1;
        int quarter = QUARTER_MAP.get(month);
        
        // 將分片策略設(shè)計為按季度循環(huán)到不同數(shù)據(jù)源
        // 例如：2023Q1->ds0, 2023Q2->ds1, 2023Q3->ds2, 2023Q4->ds3, 2024Q1->ds0, ...
        int shardIndex = ((year - 2023) * 4 + quarter - 1) % 4;
        
        for (String targetName : availableTargetNames) {
            if (targetName.endsWith(String.valueOf(shardIndex))) {
                return targetName;
            }
        }
        
        throw new UnsupportedOperationException("No available target name for date: " + date);
    }
    
    // 其他必要的方法實現(xiàn)...
}

@Entity
@Table(name = "t_order")
public class Order {
    @Id
    private Long orderId;
    private Long userId;
    @Temporal(TemporalType.TIMESTAMP)
    private Date createTime;  // 時間分片鍵
    private BigDecimal amount;
    private String status;
    // getters and setters
}