Oracle、MySQL、PostgreSQL三大数据库对比分析

Oracle、MySQL、PostgreSQL 三大数据库的对比分析，结合 Java SpringBoot 项目开发 的实际场景，重点说明分库分表、主从复制的实现难度及案例。

一、数据库核心对比

1. 核心区别与适用场景

二、SpringBoot 项目中的分库分表实现

1. MySQL + ShardingSphere

• 难度：⭐️⭐️⭐️
• 实现步骤：
  1. 依赖引入：

     <dependency>
         <groupId>org.apache.shardingsphere</groupId>
         <artifactId>shardingsphere-jdbc-core</artifactId>
         <version>5.3.2</version>
     </dependency>
     

  2. 分片规则配置（application-sharding.yml）：

     dataSources:
       ds0: !!com.zaxxer.hikari.HikariDataSource
         jdbcUrl: jdbc:mysql://db0:3306/db
         username: root
         password: root
       ds1: !!com.zaxxer.hikari.HikariDataSource
         jdbcUrl: jdbc:mysql://db1:3306/db
         username: root
         password: root
     rules:
     - !SHARDING
       tables:
         user:
           actualDataNodes: ds${0..1}.user_${0..1}
           tableStrategy:
             standard:
               shardingColumn: user_id
               shardingAlgorithmName: user_table_hash
     

  3. SpringBoot 主类：

     @SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
     public class App {
         public static void main(String[] args) {
             SpringApplication.run(App.class, args);
         }
     }
     

• 痛点：
  • 跨库 JOIN 需业务层处理。
  • 分布式事务需整合 Seata。

2. PostgreSQL + Citus

• 难度：⭐️⭐️
• 实现步骤：
  1. 启用 Citus 扩展：

     CREATE EXTENSION citus;
     

  2. 创建分布式表：

     SELECT create_distributed_table('user', 'user_id');
     

  3. SpringBoot 配置（无代码侵入，直接操作分布式表）：

     spring:
       datasource:
         url: jdbc:postgresql://citus-coordinator:5432/db
         username: postgres
         password: postgres
     

• 痛点：
  • Citus 需预装插件，集群部署复杂。
  • 复杂查询可能跨节点执行效率低。

3. Oracle 分区表

• 难度：⭐️⭐️⭐️⭐️
• 实现步骤：
  1. 创建范围分区表：

     CREATE TABLE orders (
       order_id NUMBER,
       order_date DATE
     ) PARTITION BY RANGE (order_date) (
       PARTITION orders_2023 VALUES LESS THAN (TO_DATE('2024-01-01', 'YYYY-MM-DD')),
       PARTITION orders_2024 VALUES LESS THAN (MAXVALUE)
     );
     

  2. SpringBoot 配置（直接使用 JPA/Hibernate）：

     spring:
       datasource:
         url: jdbc:oracle:thin:@//oracle-host:1521/ORCL
         username: admin
         password: admin
     

• 痛点：
  • 分区维护需手动操作，扩展性差。
  • 分库分表依赖 GoldenGate，成本高昂。

三、SpringBoot 项目中的主从复制实现

1. MySQL 主从复制 + 读写分离

• 难度：⭐️⭐️
• 实现步骤：
  1. MySQL 主从配置：
     • 主库开启 Binlog，从库通过 CHANGE MASTER TO 同步。
  2. SpringBoot 多数据源配置：

     @Configuration
     public class DataSourceConfig {
         @Bean
         @Primary
         @ConfigurationProperties("spring.datasource.master")
         public DataSource masterDataSource() {
             return DataSourceBuilder.create().build();
         }
     
         @Bean
         @ConfigurationProperties("spring.datasource.slave")
         public DataSource slaveDataSource() {
             return DataSourceBuilder.create().build();
         }
     
         @Bean
         public DataSource routingDataSource() {
             Map<Object, Object> targetDataSources = new HashMap<>();
             targetDataSources.put("master", masterDataSource());
             targetDataSources.put("slave", slaveDataSource());
             AbstractRoutingDataSource routingDataSource = new AbstractRoutingDataSource() {
                 @Override
                 protected Object determineCurrentLookupKey() {
                     return TransactionSynchronizationManager.isCurrentTransactionReadOnly() ? "slave" : "master";
                 }
             };
             routingDataSource.setTargetDataSources(targetDataSources);
             return routingDataSource;
         }
     }
     

  3. 事务注解：

     @Transactional(readOnly = true)  // 读操作走从库
     public User getUser(Long id) {
         return userRepository.findById(id).orElse(null);
     }
     

2. PostgreSQL 流复制 + HikariCP 配置

• 难度：⭐️⭐️⭐️
• 实现步骤：
  1. PostgreSQL 主从流复制配置（基于 WAL 日志）。
  2. SpringBoot 多数据源配置（类似 MySQL）。
  3. 使用 @Transactional(readOnly = true) 注解路由读请求。

3. Oracle Data Guard

• 难度：⭐️⭐️⭐️⭐️
• 实现步骤：
  1. 配置 Data Guard 物理备库。
  2. SpringBoot 多数据源（需手动切换连接，无自动路由）。

四、总结与选型建议

SpringBoot 项目选型指南

分库分表 vs 主从复制

• 分库分表：解决 数据量大 问题，适合写密集型场景（如电商订单）。
• 主从复制：解决 高并发读 问题，适合读多写少场景（如内容平台）。

代码示例重点

• MySQL 分库分表使用 ShardingSphere 的 YAML 配置。
• 主从复制通过 SpringBoot 多数据源 + 事务注解实现路由。
• PostgreSQL Citus 无需代码修改，直接通过 SQL 管理分布式表。