Spring Boot：多异名同结构数据库共用实体取数方案

针对结构一致但库名不同的多数据库场景，核心思路是复用同一实体定义，动态切换数据库连接，下面提供几种实用的实现方式：

1. Python SQLAlchemy 复用实体查询 #

SQLAlchemy支持动态创建数据库引擎和会话，只需定义一次实体类即可遍历所有库查询：

from sqlalchemy import Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

Base = declarative_base()

# 通用实体类，对应所有库中结构相同的表
class Cat(Base):
    __tablename__ = 'cats'  # 假设所有库的目标表名都是cats
    id = Column(Integer, primary_key=True)
    name = Column(String(50))
    age = Column(Integer)

# 所有数据库的连接配置
db_configs = {
    'cat_1': 'mysql+pymysql://username:password@localhost/cat_1',
    'cat_2': 'mysql+pymysql://username:password@localhost/cat_2',
    'cat_3': 'mysql+pymysql://username:password@localhost/cat_3',
    # 补充剩余库的连接字符串
}

# 遍历每个数据库执行查询
for db_name, db_url in db_configs.items():
    # 动态创建当前库的引擎和会话
    engine = create_engine(db_url)
    Session = sessionmaker(bind=engine)
    session = Session()
    
    # 复用Cat实体执行查询逻辑
    cats = session.query(Cat).filter(Cat.age > 2).all()
    
    print(f"[{db_name}] 查询结果:")
    for cat in cats:
        print(f"ID: {cat.id}, 名称: {cat.name}, 年龄: {cat.age}")
    
    session.close()

2. 原生SQL直接拼接库名（通用语言方案） #

如果不需要ORM的封装，直接通过原生SQL拼接库名是最简洁的方式，以Python pymysql为例：

import pymysql

# 基础数据库配置（不含库名）
base_config = {
    'user': 'username',
    'password': 'password',
    'host': 'localhost',
    'charset': 'utf8mb4'
}

# 目标库名列表
db_names = ['cat_1', 'cat_2', 'cat_3', 'cat_4', 'cat_5']

for db_name in db_names:
    # 连接当前数据库
    conn = pymysql.connect(database=db_name, **base_config)
    cursor = conn.cursor(pymysql.cursors.DictCursor)
    
    # 拼接库名执行SQL
    sql = f"SELECT id, name, age FROM {db_name}.cats WHERE age > 2"
    cursor.execute(sql)
    cats = cursor.fetchall()
    
    print(f"[{db_name}] 查询结果:")
    for cat in cats:
        print(f"ID: {cat['id']}, 名称: {cat['name']}, 年龄: {cat['age']}")
    
    cursor.close()
    conn.close()

3. Java Spring Data JPA 动态数据源方案 #

在Spring项目中，可以通过AbstractRoutingDataSource实现动态数据源切换，复用同一Repository和实体类：

第一步：定义动态数据源路由 #

public class DynamicDataSource extends AbstractRoutingDataSource {
    @Override
    protected Object determineCurrentLookupKey() {
        return DataSourceContextHolder.getDbName();
    }
}

// 线程安全的数据源上下文持有类
public class DataSourceContextHolder {
    private static final ThreadLocal<String> DB_HOLDER = new ThreadLocal<>();
    
    public static void setDbName(String dbName) {
        DB_HOLDER.set(dbName);
    }
    
    public static String getDbName() {
        return DB_HOLDER.get();
    }
    
    public static void clear() {
        DB_HOLDER.remove();
    }
}

第二步：配置多数据源和JPA #

@Configuration
@EnableJpaRepositories(
    basePackages = "com.yourpackage.repository",
    entityManagerFactoryRef = "dynamicEntityManagerFactory",
    transactionManagerRef = "dynamicTransactionManager"
)
public class DataSourceConfig {

    // 配置cat_1数据源
    @Bean
    public DataSource cat1DataSource() {
        DriverManagerDataSource ds = new DriverManagerDataSource();
        ds.setDriverClassName("com.mysql.cj.jdbc.Driver");
        ds.setUrl("jdbc:mysql://localhost/cat_1");
        ds.setUsername("username");
        ds.setPassword("password");
        return ds;
    }

    // 配置cat_2数据源（其余库类似）
    @Bean
    public DataSource cat2DataSource() {
        DriverManagerDataSource ds = new DriverManagerDataSource();
        ds.setDriverClassName("com.mysql.cj.jdbc.Driver");
        ds.setUrl("jdbc:mysql://localhost/cat_2");
        ds.setUsername("username");
        ds.setPassword("password");
        return ds;
    }

    // 配置动态数据源
    @Bean
    public DynamicDataSource dynamicDataSource() {
        DynamicDataSource ds = new DynamicDataSource();
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put("cat_1", cat1DataSource());
        targetDataSources.put("cat_2", cat2DataSource());
        // 添加剩余库的数据源映射
        ds.setTargetDataSources(targetDataSources);
        ds.setDefaultTargetDataSource(cat1DataSource());
        return ds;
    }

    // 配置EntityManagerFactory
    @Bean
    public LocalContainerEntityManagerFactoryBean dynamicEntityManagerFactory(EntityManagerFactoryBuilder builder) {
        return builder
                .dataSource(dynamicDataSource())
                .packages("com.yourpackage.entity")
                .persistenceUnit("dynamicPU")
                .build();
    }

    // 配置事务管理器
    @Bean
    public PlatformTransactionManager dynamicTransactionManager(EntityManagerFactory dynamicEntityManagerFactory) {
        return new JpaTransactionManager(dynamicEntityManagerFactory);
    }
}

第三步：定义通用实体和Repository #

// 通用实体类
@Entity
@Table(name = "cats")
public class Cat {
    @Id
    private Integer id;
    private String name;
    private Integer age;

    // Getter、Setter省略
}

// 通用Repository接口
public interface CatRepository extends JpaRepository<Cat, Integer> {
    List<Cat> findByAgeGreaterThan(Integer age);
}

第四步：业务层切换数据源查询 #

@Service
public class CatService {
    @Autowired
    private CatRepository catRepository;

    public List<Cat> getCatsFromDb(String dbName) {
        try {
            DataSourceContextHolder.setDbName(dbName);
            return catRepository.findByAgeGreaterThan(2);
        } finally {
            DataSourceContextHolder.clear();
        }
    }
}

内容的提问来源于stack exchange，提问作者mohammad mehdi khajehzadeh