<dependencies>
    <!-- Spring Boot 基礎(chǔ)依賴 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>

    <!-- ShardingSphere-JDBC for Spring Boot -->
    <dependency>
        <groupId>org.apache.shardingsphere</groupId>
        <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
        <version>5.0.0</version> <!-- 請(qǐng)根據(jù)需要選擇合適的版本 -->
    </dependency>

    <!-- MySQL 驅(qū)動(dòng) -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>

    <!-- SQL Server 驅(qū)動(dòng) -->
    <dependency>
        <groupId>com.microsoft.sqlserver</groupId>
        <artifactId>mssql-jdbc</artifactId>
        <version>9.4.1.jre8</version>
    </dependency>

    <!-- Oracle 驅(qū)動(dòng) -->
    <dependency>
        <groupId>com.oracle.database.jdbc</groupId>
        <artifactId>ojdbc8</artifactId>
        <version>19.8.0.0</version>
    </dependency>

    <!-- PostgreSQL 驅(qū)動(dòng) -->
    <dependency>
        <groupId>org.postgresql</groupId>
        <artifactId>postgresql</artifactId>
        <version>42.5.0</version>
    </dependency>
</dependencies>

spring:
  datasource:
    # 配置 MySQL 數(shù)據(jù)源
    mysql:
      url: jdbc:mysql://localhost:3306/mysql_db
      username: root
      password: root
      driver-class-name: com.mysql.cj.jdbc.Driver

    # 配置 SQL Server 數(shù)據(jù)源
    sqlserver:
      url: jdbc:sqlserver://localhost:1433;databaseName=sqlserver_db
      username: sa
      password: password
      driver-class-name: com.microsoft.sqlserver.jdbc.SQLServerDriver

    # 配置 Oracle 數(shù)據(jù)源
    oracle:
      url: jdbc:oracle:thin:@localhost:1521:orcl
      username: oracle
      password: oracle
      driver-class-name: oracle.jdbc.OracleDriver

    # 配置 PostgreSQL 數(shù)據(jù)源
    postgresql:
      url: jdbc:postgresql://localhost:5432/postgresql_db
      username: postgres
      password: password
      driver-class-name: org.postgresql.Driver

  sharding:
    jdbc:
      config:
        data-source:
          mysql:
            url: jdbc:mysql://localhost:3306/mysql_db
            username: root
            password: root
            driver-class-name: com.mysql.cj.jdbc.Driver
          sqlserver:
            url: jdbc:sqlserver://localhost:1433;databaseName=sqlserver_db
            username: sa
            password: password
            driver-class-name: com.microsoft.sqlserver.jdbc.SQLServerDriver
          oracle:
            url: jdbc:oracle:thin:@localhost:1521:orcl
            username: oracle
            password: oracle
            driver-class-name: oracle.jdbc.OracleDriver
          postgresql:
            url: jdbc:postgresql://localhost:5432/postgresql_db
            username: postgres
            password: password
            driver-class-name: org.postgresql.Driver

      rules:
        sharding:
          tables:
            order:
              actual-data-nodes: mysql.order_${0..1},sqlserver.order_${0..1},oracle.order_${0..1},postgresql.order_${0..1}
              table-strategy:
                inline:
                  sharding-column: order_id
                  algorithm-expression: order_${order_id % 2}
            user:
              actual-data-nodes: mysql.user_${0..1},sqlserver.user_${0..1},oracle.user_${0..1},postgresql.user_${0..1}
              table-strategy:
                inline:
                  sharding-column: user_id
                  algorithm-expression: user_${user_id % 2}

@Configuration
@EnableTransactionManagement
public class ShardingConfig {

    @Bean
    public DataSource dataSource() throws SQLException {
        return ShardingDataSourceFactory.createDataSource(createDataSourceMap(), createShardingRuleConfig());
    }

    private Map<String, DataSource> createDataSourceMap() {
        Map<String, DataSource> dataSourceMap = new HashMap<>();
        dataSourceMap.put("mysql", createDataSource("mysql"));
        dataSourceMap.put("sqlserver", createDataSource("sqlserver"));
        dataSourceMap.put("oracle", createDataSource("oracle"));
        dataSourceMap.put("postgresql", createDataSource("postgresql"));
        return dataSourceMap;
    }

    private DataSource createDataSource(String dataSourceName) {
        HikariDataSource dataSource = new HikariDataSource();
        switch (dataSourceName) {
            case "mysql":
                dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/mysql_db");
                dataSource.setUsername("root");
                dataSource.setPassword("root");
                dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
                break;
            case "sqlserver":
                dataSource.setJdbcUrl("jdbc:sqlserver://localhost:1433;databaseName=sqlserver_db");
                dataSource.setUsername("sa");
                dataSource.setPassword("password");
                dataSource.setDriverClassName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
                break;
            case "oracle":
                dataSource.setJdbcUrl("jdbc:oracle:thin:@localhost:1521:orcl");
                dataSource.setUsername("oracle");
                dataSource.setPassword("oracle");
                dataSource.setDriverClassName("oracle.jdbc.OracleDriver");
                break;
            case "postgresql":
                dataSource.setJdbcUrl("jdbc:postgresql://localhost:5432/postgresql_db");
                dataSource.setUsername("postgres");
                dataSource.setPassword("password");
                dataSource.setDriverClassName("org.postgresql.Driver");
                break;
            default:
                throw new IllegalArgumentException("Unsupported DataSource");
        }
        return dataSource;
    }

    private ShardingRuleConfiguration createShardingRuleConfig() {
        ShardingRuleConfiguration shardingRuleConfig = new ShardingRuleConfiguration();

        // 配置訂單表的分片規(guī)則
        shardingRuleConfig.getTableRuleConfigs().add(createOrderTableRule());
        // 配置用戶表的分片規(guī)則
        shardingRuleConfig.getTableRuleConfigs().add(createUserTableRule());

        // 設(shè)置默認(rèn)數(shù)據(jù)源
        shardingRuleConfig.setDefaultDataSourceName("mysql");

        return shardingRuleConfig;
    }

    private TableRuleConfiguration createOrderTableRule() {
        TableRuleConfiguration orderTableRuleConfig = new TableRuleConfiguration();
        orderTableRuleConfig.setLogicTable("order");
        orderTableRuleConfig.setActualDataNodes("mysql.order_${0..1},sqlserver.order_${0..1},oracle.order_${0..1},postgresql.order_${0..1}");
        orderTableRuleConfig.setTableShardingStrategyConfig(new InlineShardingStrategyConfiguration("order_id", "order_${order_id % 2}"));
        return orderTableRuleConfig;
    }

    private TableRuleConfiguration createUserTableRule() {
        TableRuleConfiguration userTableRuleConfig = new TableRuleConfiguration();
        userTableRuleConfig.setLogicTable("user");
        userTableRuleConfig.setActualDataNodes("mysql.user_${0..1},sqlserver.user_${0..1},oracle.user_${0..1},postgresql.user_${0..1}");
        userTableRuleConfig.setTableShardingStrategyConfig(new InlineShardingStrategyConfiguration("user_id", "user_${user_id % 2}"));
        return userTableRuleConfig;
    }
}

@Entity
public class Order {

    @Id
    private Long orderId;
    private String orderDetails;

    // getters and setters
}

@Entity
public class User {

    @Id
    private Long userId;
    private String userName;

    // getters and setters
}

@RunWith(SpringRunner.class)
@SpringBootTest
public class ShardingTest {

    @Autowired
    private OrderRepository orderRepository;

    @Test
    public void testOrderSharding() {
        Order order = new Order();
        order.setOrderId(1L);
        order.setOrderDetails("Test order");
        orderRepository.save(order);

        Optional<Order> savedOrder = orderRepository.findById(1L);
        assertTrue(savedOrder.isPresent());
    }
}