TypeORM数据源与连接管理：企业级应用架构设计
项目地址: https://gitcode.com/GitHub_Trending/ty/typeorm 本文深入探讨了TypeORM在企业级应用中的数据源配置、多数据源管理、连接池优化策略、事务管理机制以及复制与读写分离架构的实现。内容涵盖了DataSource基础配置详解、多数据源架构设计模式、连接池性能调优公式、事务ACID特性保障、分布式事务处理方案，以及主从复制架构的完整配置和实践指南，为构建高可用、高性能的数据库架构提供全面解决方案。
DataSource配置与多数据源管理
在现代企业级应用架构中，数据源管理是构建健壮、可扩展系统的核心要素。TypeORM 提供了强大的 DataSource 配置机制，支持复杂的企业级多数据源场景，让开发者能够优雅地处理数据库连接、连接池管理和多数据库操作。
DataSource 基础配置
DataSource 是 TypeORM 的核心连接管理对象，它封装了数据库连接的所有配置和操作。每个 DataSource 实例代表一个独立的数据库连接配置，支持多种数据库类型和连接选项。
基本配置示例
import { DataSource } from "typeorm"
import { User } from "./entity/User"
import { Product } from "./entity/Product"
// 主数据源配置
const mainDataSource = new DataSource({
type: "postgres",
host: "localhost",
port: 5432,
username: "test",
password: "test",
database: "main_db",
entities: [User, Product],
synchronize: true,
logging: true,
poolSize: 10,
extra: {
connectionTimeoutMillis: 5000,
idleTimeoutMillis: 30000
}
})
// 初始化数据源
await mainDataSource.initialize()
console.log("主数据源连接成功")
配置选项详解
TypeORM 的 DataSource 配置支持丰富的选项，满足不同场景的需求：
| 配置选项 | 类型 | 说明 | 默认值 |
|---|---|---|---|
type | string | 数据库类型 (mysql, postgres, sqlite等) | 必填 |
host | string | 数据库服务器地址 | "localhost" |
port | number | 数据库端口 | 数据库默认端口 |
username | string | 数据库用户名 | - |
password | string | 数据库密码 | - |
database | string | 数据库名称 | - |
entities | Array | 实体类数组 | [] |
synchronize | boolean | 是否自动同步schema | false |
logging | boolean | 是否启用SQL日志 | false |
poolSize | number | 连接池大小 | 10 |
name | string | 数据源名称 | "default" |
多数据源架构设计
在企业级应用中，多数据源是常见需求，TypeORM 通过命名数据源和模块化设计来支持这一场景。
多数据源配置模式
// 主业务数据库配置
export const mainDataSource = new DataSource({
name: "main",
type: "mysql",
host: process.env.DB_MAIN_HOST,
port: parseInt(process.env.DB_MAIN_PORT),
username: process.env.DB_MAIN_USER,
password: process.env.DB_MAIN_PASSWORD,
database: process.env.DB_MAIN_NAME,
entities: [User, Order, Product],
synchronize: process.env.NODE_ENV === "development",
logging: process.env.NODE_ENV === "development"
})
// 日志数据库配置
export const logDataSource = new DataSource({
name: "logs",
type: "postgres",
host: process.env.DB_LOG_HOST,
port: parseInt(process.env.DB_LOG_PORT),
username: process.env.DB_LOG_USER,
password: process.env.DB_LOG_PASSWORD,
database: process.env.DB_LOG_NAME,
entities: [AuditLog, SystemLog],
synchronize: false,
logging: false
})
// 分析数据库配置
export const analyticsDataSource = new DataSource({
name: "analytics",
type: "mongodb",
host: process.env.DB_ANALYTICS_HOST,
port: parseInt(process.env.DB_ANALYTICS_PORT),
database: process.env.DB_ANALYTICS_NAME,
entities: [UserAnalytics, EventTracking],
useUnifiedTopology: true
})
多数据源初始化策略
class DataSourceManager {
private dataSources: Map<string, DataSource> = new Map()
async initializeAll(): Promise<void> {
const sources = [mainDataSource, logDataSource, analyticsDataSource]
for (const source of sources) {
try {
await source.initialize()
this.dataSources.set(source.options.name || "default", source)
console.log(`数据源 ${source.options.name} 初始化成功`)
} catch (error) {
console.error(`数据源 ${source.options.name} 初始化失败:`, error)
throw error
}
}
}
getDataSource(name: string): DataSource {
const source = this.dataSources.get(name)
if (!source) {
throw new Error(`数据源 ${name} 未找到`)
}
return source
}
async shutdownAll(): Promise<void> {
for (const [name, source] of this.dataSources) {
if (source.isInitialized) {
await source.destroy()
console.log(`数据源 ${name} 已关闭`)
}
}
}
}
高级配置特性
连接池优化
TypeORM 提供了细粒度的连接池配置选项，确保在高并发场景下的性能表现：
const optimizedDataSource = new DataSource({
type: "postgres",
// ... 其他配置
poolSize: 20, // 最大连接数
acquireTimeout: 30000, // 获取连接超时时间(ms)
idleTimeout: 60000, // 空闲连接超时时间
connectionTimeout: 2000, // 连接建立超时时间
extra: {
max: 20, // 连接池最大大小
min: 2, // 连接池最小大小
idleTimeoutMillis: 30000, // 空闲连接超时
connectionTimeoutMillis: 2000 // 连接超时
}
})
读写分离配置
对于需要读写分离的场景，TypeORM 支持主从复制配置：
const replicationDataSource = new DataSource({
type: "mysql",
replication: {
master: {
host: "master.db.example.com",
port: 3306,
username: "master_user",
password: "master_password",
database: "myapp_db"
},
slaves: [{
host: "slave1.db.example.com",
port: 3306,
username: "slave_user",
password: "slave_password",
database: "myapp_db"
}, {
host: "slave2.db.example.com",
port: 3306,
username: "slave_user",
password: "slave_password",
database: "myapp_db"
}]
},
entities: [/* entities */],
// 其他配置...
})
配置管理最佳实践
环境敏感的配置管理
// config/database.ts
export function getDataSourceConfig(env: string): DataSourceOptions {
const baseConfig = {
type: "postgres" as const,
entities: [__dirname + "/../entities/*.js"],
migrations: [__dirname + "/../migrations/*.js"],
subscribers: [__dirname + "/../subscribers/*.js"]
}
const envConfigs = {
development: {
host: "localhost",
port: 5432,
username: "dev_user",
password: "dev_password",
database: "myapp_dev",
synchronize: true,
logging: true
},
test: {
host: "test.db.example.com",
port: 5432,
username: "test_user",
password: "test_password",
database: "myapp_test",
synchronize: false,
logging: false
},
production: {
host: process.env.DB_HOST,
port: parseInt(process.env.DB_PORT),
username: process.env.DB_USER,
password: process.env.DB_PASSWORD,
database: process.env.DB_NAME,
synchronize: false,
logging: false,
ssl: { rejectUnauthorized: false }
}
}
return { ...baseConfig, ...envConfigs[env] }
}
// 使用配置
const dataSource = new DataSource(getDataSourceConfig(process.env.NODE_ENV))
健康检查与监控
class DataSourceHealthChecker {
constructor(private dataSource: DataSource) {}
async checkHealth(): Promise<HealthStatus> {
try {
// 执行简单查询检查连接状态
const result = await this.dataSource.query("SELECT 1 as health_check")
return {
status: "healthy",
timestamp: new Date(),
details: { query_result: result[0] }
}
} catch (error) {
return {
status: "unhealthy",
timestamp: new Date(),
error: error.message
}
}
}
async monitor(intervalMs: number = 30000): Promise<void> {
setInterval(async () => {
const health = await this.checkHealth()
if (health.status === "unhealthy") {
console.error("数据库连接异常:", health.error)
// 触发告警或重连逻辑
}
}, intervalMs)
}
}
interface HealthStatus {
status: "healthy" | "unhealthy"
timestamp: Date
details?: any
error?: string
}
错误处理与重试机制
连接失败的重试策略
async function initializeWithRetry(
dataSource: DataSource,
maxRetries: number = 3,
delayMs: number = 1000
): Promise<void> {
let attempt = 0
while (attempt < maxRetries) {
try {
await dataSource.initialize()
return
} catch (error) {
attempt++
if (attempt === maxRetries) {
throw new Error(`数据源初始化失败，尝试 ${maxRetries} 次后仍无法连接: ${error.message}`)
}
console.warn(`数据源初始化失败，第 ${attempt} 次重试...`)
await new Promise(resolve => setTimeout(resolve, delayMs * attempt))
}
}
}
// 使用重试机制
await initializeWithRetry(mainDataSource, 5, 2000)
事务边界与数据源切换
class TransactionalService {
constructor(
private mainDataSource: DataSource,
private logDataSource: DataSource
) {}
async executeBusinessOperation(userData: any): Promise<void> {
// 在主数据源中执行事务
await this.mainDataSource.transaction(async transactionalEntityManager => {
// 业务逻辑操作
const user = transactionalEntityManager.create(User, userData)
await transactionalEntityManager.save(user)
// 同时在日志数据源中记录操作
await this.logDataSource.manager.transaction(async logEntityManager => {
const logEntry = logEntityManager.create(AuditLog, {
action: "USER_CREATE",
userId: user.id,
timestamp: new Date()
})
await logEntityManager.save(logEntry)
})
})
}
}
通过这种架构设计，TypeORM 的多数据源管理能够满足企业级应用对数据库连接的高可用性、可扩展性和维护性的要求，为复杂的业务场景提供强有力的数据访问支撑。
连接池优化与数据库连接策略
在企业级应用架构设计中，数据库连接管理是确保应用性能和可扩展性的关键因素。TypeORM作为一款功能强大的ORM框架，提供了完善的连接池管理机制，支持多种数据库的连接池优化策略。
连接池核心配置参数
TypeORM通过BaseDataSourceOptions接口提供了丰富的连接池配置选项，这些配置直接影响应用的性能和资源利用率：
| 配置参数 | 类型 | 默认值 | 描述 |
|---|---|---|---|
poolSize | number | 10 | 连接池最大连接数 |
acquireTimeout | number | 10000 | 获取连接超时时间(ms) |
connectTimeout | number | 10000 | 连接建立超时时间(ms) |
// TypeORM 数据源连接池配置示例
import { DataSource } from "typeorm"
const dataSource = new DataSource({
type: "mysql",
host: "localhost",
port: 3306,
username: "root",
password: "password",
database: "test",
poolSize: 20, // 最大连接数
acquireTimeout: 15000, // 获取连接超时15秒
connectTimeout: 10000, // 连接建立超时10秒
extra: {
connectionLimit: 20, // 底层驱动连接限制
acquireTimeout: 15000,
timeout: 10000
}
})
数据库驱动层连接池实现
TypeORM针对不同数据库提供了专门的连接池实现策略：
MySQL连接池架构
MySQL驱动支持两种连接池模式：
- 标准连接池模式：用于单数据库实例
- 集群连接池模式：用于主从复制环境
// 主从复制配置示例
const replicationConfig = {
type: "mysql",
replication: {
master: {
host: "master.db.example.com",
username: "user",
password: "password",
database: "app_db"
},
slaves: [
{
host: "slave1.db.example.com",
username: "user",
password: "password",
database: "app_db"
},
{
host: "slave2.db.example.com",
username: "user",
password: "password",
database: "app_db"
}
],
removeNodeErrorCount: 5, // 节点错误次数阈值
restoreNodeTimeout: 0, // 节点恢复时间
selector: "RR" // 轮询选择策略
},
poolSize: 15
}
PostgreSQL连接池优化
PostgreSQL驱动通过node-postgres库实现连接池，支持更细粒度的配置：
const postgresConfig = {
type: "postgres",
host: "localhost",
port: 5432,
username: "user",
password: "password",
database: "app_db",
poolSize: 25,
extra: {
max: 25, // 最大连接数
idleTimeoutMillis: 30000, // 空闲连接超时
connectionTimeoutMillis: 10000 // 连接超时
},
poolErrorHandler: (err) => {
console.error("连接池错误:", err)
// 自定义错误处理逻辑
}
}
连接池性能优化策略
1. 连接数调优公式
根据应用特性计算最优连接池大小：
optimal_pool_size = (core_count * 2) + effective_spindle_count
- CPU密集型应用：
poolSize = CPU核心数 * 2 - IO密集型应用：
poolSize = CPU核心数 * 4 + 磁盘数
2. 连接生命周期管理
3. 监控与告警配置
实现连接池健康监控：
// 连接池监控实现
setInterval(() => {
const pool = dataSource.driver.pool
console.log(`活跃连接: ${pool._allConnections.length}`)
console.log(`空闲连接: ${pool._freeConnections.length}`)
console.log(`等待队列: ${pool._connectionQueue.length}`)
// 触发告警条件
if (pool._connectionQueue.length > 10) {
alert('连接池排队严重，考虑扩容')
}
}, 30000)
企业级最佳实践
1. 多环境配置策略
// 环境特定的连接池配置
const getPoolConfig = (env: string) => {
const baseConfig = {
development: { poolSize: 10, acquireTimeout: 5000 },
staging: { poolSize: 30, acquireTimeout: 10000 },
production: { poolSize: 50, acquireTimeout: 15000 }
}
return baseConfig[env] || baseConfig.development
}
const dataSource = new DataSource({
...databaseConfig,
...getPoolConfig(process.env.NODE_ENV)
})
2. 连接池预热策略
应用启动时预热连接池：
async function warmupConnectionPool(dataSource: DataSource) {
const connections = []
const warmupCount = Math.min(5, dataSource.options.poolSize || 10)
for (let i = 0; i < warmupCount; i++) {
const connection = await dataSource.createQueryRunner()
connections.push(connection)
}
// 立即释放，保持连接池中有空闲连接
await Promise.all(connections.map(conn => conn.release()))
}
3. 故障转移与重试机制
// 带重试的连接获取策略
async function getConnectionWithRetry(
dataSource: DataSource,
maxRetries = 3,
retryDelay = 1000
) {
for (let attempt = 1; attempt <= maxRetries; attempt++) {
try {
return await dataSource.createQueryRunner()
} catch (error) {
if (attempt === maxRetries) throw error
await new Promise(resolve => setTimeout(resolve, retryDelay * attempt))
}
}
}
性能指标监控表
建立连接池性能监控指标体系：
| 指标名称 | 监控目标 | 告警阈值 | 优化建议 |
|---|---|---|---|
| 连接获取时间 | < 100ms | > 500ms | 增加poolSize或优化查询 |
| 连接等待队列 | < 5 | > 10 | 扩容连接池或优化业务逻辑 |
| 连接空闲率 | 20%-80% | < 10% 或 > 90% | 调整poolSize配置 |
| 错误连接率 | < 1% | > 5% | 检查数据库健康状态 |
高级连接策略
1. 读写分离连接池
// 读写分离配置
const readWriteDataSource = new DataSource({
type: "mysql",
replication: {
master: { host: "write.db.com" },
slaves: [
{ host: "read1.db.com" },
{ host: "read2.db.com" }
]
},
poolSize: 20,
// 读写超时差异化配置
extra: {
write: { connectTimeout: 5000 },
read: { connectTimeout: 3000 }
}
})
2. 连接池分片策略
对于大型应用，采用分片策略避免单点瓶颈：
// 基于业务分片的连接池
const shardedDataSources = {
users: new DataSource({ /* 用户相关配置 */ }),
orders: new DataSource({ /* 订单相关配置 */ }),
products: new DataSource({ /* 商品相关配置 */ })
}
// 根据业务类型选择连接池
function getShardedDataSource(entity: string): DataSource {
return shardedDataSources[entity] || shardedDataSources.default
}
通过合理的连接池配置和优化策略，TypeORM能够为企业级应用提供稳定高效的数据库连接管理，确保系统在高并发场景下的性能和可靠性。正确的连接池配置可以显著降低数据库负载，提高应用响应速度，并为系统扩展提供坚实基础。
事务管理与原子性操作保障
在企业级应用开发中，事务管理是确保数据一致性和完整性的核心机制。TypeORM 提供了强大而灵活的事务管理能力，支持多种事务处理模式，从简单的手动事务到复杂的分布式事务场景。
事务的基本概念与ACID特性
事务是数据库操作的最小工作单元，具有ACID四大特性：
| 特性 | 描述 | TypeORM支持 |
|---|---|---|
| 原子性(Atomicity) | 事务中的所有操作要么全部成功，要么全部失败 | ✅ 完全支持 |
| 一致性(Consistency) | 事务执行前后数据库状态保持一致 | ✅ 通过约束和验证 |
| 隔离性(Isolation) | 并发事务之间相互隔离 | ✅ 支持多种隔离级别 |
| 持久性(Durability) | 事务提交后结果永久保存 | ✅ 依赖底层数据库 |
TypeORM事务管理核心接口
TypeORM通过QueryRunner接口提供完整的事务控制能力：
interface QueryRunner {
// 事务状态管理
readonly isTransactionActive: boolean
startTransaction(isolationLevel?: IsolationLevel): Promise<void>
commitTransaction(): Promise<void>
rollbackTransaction(): Promise<void>
// 连接管理
connect(): Promise<any>
release(): Promise<void>
}
手动事务管理示例
手动事务提供最精细的控制，适合复杂业务场景：
import { DataSource } from "typeorm"
import { IsolationLevel } from "typeorm/driver/types/IsolationLevel"
async function transferFunds(
fromAccountId: number,
toAccountId: number,
amount: number
) {
const dataSource = await getDataSource()
const queryRunner = dataSource.createQueryRunner()
try {
// 获取连接并开始事务
await queryRunner.connect()
await queryRunner.startTransaction(IsolationLevel.READ_COMMITTED)
const accountRepository = queryRunner.manager.getRepository(Account)
// 扣减转出账户余额
const fromAccount = await accountRepository.findOneBy({ id: fromAccountId })
if (!fromAccount || fromAccount.balance < amount) {
throw new Error("余额不足")
}
fromAccount.balance -= amount
await accountRepository.save(fromAccount)
// 增加转入账户余额
const toAccount = await accountRepository.findOneBy({ id: toAccountId })
if (!toAccount) {
throw new Error("目标账户不存在")
}
toAccount.balance += amount
await accountRepository.save(toAccount)
// 记录交易流水
const transaction = new Transaction()
transaction.fromAccountId = fromAccountId
transaction.toAccountId = toAccountId
transaction.amount = amount
transaction.timestamp = new Date()
await queryRunner.manager.save(transaction)
// 提交事务
await queryRunner.commitTransaction()
return { success: true, message: "转账成功" }
} catch (error) {
// 回滚事务
await queryRunner.rollbackTransaction()
return { success: false, message: error.message }
} finally {
// 释放连接
await queryRunner.release()
}
}
声明式事务管理
TypeORM支持通过装饰器实现声明式事务，简化代码结构：
import { Transaction, TransactionManager, TransactionRepository } from "typeorm"
class BankingService {
@Transaction()
async transferFunds(
@TransactionManager() manager: EntityManager,
fromAccountId: number,
toAccountId: number,
amount: number
) {
const accountRepository = manager.getRepository(Account)
const transactionRepository = manager.getRepository(Transaction)
const fromAccount = await accountRepository.findOneBy({ id: fromAccountId })
const toAccount = await accountRepository.findOneBy({ id: toAccountId })
// 业务逻辑...
}
}
事务隔离级别支持
TypeORM支持标准的事务隔离级别，确保并发场景下的数据一致性：
分布式事务处理
对于跨多个数据源或微服务的事务，TypeORM支持XA事务模式：
async function distributedTransaction() {
const dataSource1 = await getDataSource1()
const dataSource2 = await getDataSource2()
const queryRunner1 = dataSource1.createQueryRunner()
const queryRunner2 = dataSource2.createQueryRunner()
try {
await queryRunner1.connect()
await queryRunner2.connect()
// 开始分布式事务
await queryRunner1.startTransaction()
await queryRunner2.startTransaction()
// 执行跨数据源操作
await operationOnDataSource1(queryRunner1.manager)
await operationOnDataSource2(queryRunner2.manager)
// 提交所有事务
await queryRunner1.commitTransaction()
await queryRunner2.commitTransaction()
} catch (error) {
// 回滚所有事务
await queryRunner1.rollbackTransaction()
await queryRunner2.rollbackTransaction()
throw error
} finally {
await queryRunner1.release()
await queryRunner2.release()
}
}
事务超时与重试机制
在企业级应用中，事务超时和重试是必备的容错机制：
async function withRetry<T>(
operation: () => Promise<T>,
maxRetries: number = 3,
timeoutMs: number = 5000
): Promise<T> {
let lastError: Error
for (let attempt = 1; attempt <= maxRetries; attempt++) {
try {
return await Promise.race([
operation(),
new Promise((_, reject) =>
setTimeout(() => reject(new Error("事务超时")), timeoutMs)
)
])
} catch (error) {
lastError = error
if (isRetryableError(error) && attempt < maxRetries) {
await delay(attempt * 1000) // 指数退避
continue
}
throw error
}
}
throw lastError
}
// 使用重试机制的事务
async function robustTransaction() {
return await withRetry(async () => {
const queryRunner = dataSource.createQueryRunner()
try {
await queryRunner.connect()
await queryRunner.startTransaction()
// 业务操作
await businessOperation(queryRunner.manager)
await queryRunner.commitTransaction()
return { success: true }
} catch (error) {
await queryRunner.rollbackTransaction()
throw error
} finally {
await queryRunner.release()
}
})
}
事务监控与诊断
完善的监控体系是保障事务健康运行的关键：
class TransactionMonitor {
private static activeTransactions = new Map<string, TransactionInfo>()
static startMonitoring(queryRunner: QueryRunner, operation: string) {
const transactionId = generateId()
const startTime = Date.now()
this.activeTransactions.set(transactionId, {
id: transactionId,
operation,
startTime,
queryRunner,
status: 'active'
})
return transactionId
}
static endMonitoring(transactionId: string, status: 'committed' | 'rolledback') {
const info = this.activeTransactions.get(transactionId)
if (info) {
info.endTime = Date.now()
info.duration = info.endTime - info.startTime
info.status = status
this.logTransaction(info)
this.activeTransactions.delete(transactionId)
}
}
private static logTransaction(info: TransactionInfo) {
console.log(`事务 ${info.id} [${info.operation}] ${info.status}, 耗时: ${info.duration}ms`)
}
}
最佳实践与性能优化
- 事务粒度控制：保持事务尽可能短小，减少锁竞争
- 连接池优化：合理配置连接池大小，避免连接泄漏
- 死锁检测：实现死锁检测和自动重试机制
- 批量操作：在事务中使用批量操作减少数据库往返
// 批量操作优化示例
async function batchOperationsInTransaction() {
const queryRunner = dataSource.createQueryRunner()
try {
await queryRunner.connect()
await queryRunner.startTransaction()
const repository = queryRunner.manager.getRepository(User)
// 批量插入
const users = generateUsers(1000)
await repository.insert(users)
// 批量更新
await repository
.createQueryBuilder()
.update(User)
.set({ status: 'active' })
.where('createdAt > :date', { date: new Date('2024-01-01') })
.execute()
await queryRunner.commitTransaction()
} catch (error) {
await queryRunner.rollbackTransaction()
throw error
} finally {
await queryRunner.release()
}
}
通过上述机制，TypeORM为企业级应用提供了完整的事务管理解决方案，确保数据操作的原子性、一致性和可靠性。
复制与读写分离架构实现
在现代企业级应用中，数据库的高可用性和性能扩展是至关重要的需求。TypeORM通过内置的复制与读写分离功能，为开发者提供了强大的数据库架构支持，能够有效应对高并发场景下的数据访问压力。
复制架构的核心配置
TypeORM的复制功能主要通过数据源配置中的replication选项实现，支持主从架构的自动路由。以下是一个完整的MySQL复制配置示例：
import { DataSource } from "typeorm"
const dataSource = new DataSource({
type: "mysql",
replication: {
master: {
host: "master-db.example.com",
port: 3306,
username: "master_user",
password: "master_password",
database: "my_database"
},
slaves: [
{
host: "slave1-db.example.com",
port: 3306,
username: "slave_user",
password: "slave_password",
database: "my_database"
},
{
host: "slave2-db.example.com",
port: 3306,
username: "slave_user",
password: "slave_password",
database: "my_database"
}
],
selector: "RR", // 轮询选择从库
canRetry: true, // 连接失败时重试
removeNodeErrorCount: 5, // 错误次数阈值
restoreNodeTimeout: 60000 // 节点恢复时间
},
entities: [User, Product, Order],
synchronize: false
})
读写分离策略机制
TypeORM内部实现了智能的查询路由机制，根据操作类型自动选择合适的数据源：
高级配置选项详解
TypeORM提供了丰富的复制配置选项来满足不同场景的需求：
| 配置选项 | 类型 | 默认值 | 说明 |
|---|---|---|---|
selector | string | "RR" | 从库选择策略：RR(轮询)、RANDOM(随机)、ORDER(顺序) |
canRetry | boolean | true | 连接失败时是否尝试重连 |
removeNodeErrorCount | number | 5 | 节点错误次数阈值，超过则移除节点 |
restoreNodeTimeout | number | 0 | 节点恢复时间(毫秒)，0表示永不恢复 |
defaultMode | ReplicationMode | "slave" | 默认连接模式，可选"master"或"slave" |
手动控制复制模式
在某些特殊场景下，开发者可能需要手动控制查询的路由策略。TypeORM提供了灵活的API来实现这一需求：
// 强制使用主库进行查询
const user = await dataSource
.createQueryBuilder(User, "user")
.setReplicationMode("master")
.where("user.id = :id", { id: 1 })
.getOne()
// 在事务中自动使用主库
await dataSource.transaction(async (transactionalEntityManager) => {
// 所有操作都在主库执行
const user = await transactionalEntityManager.findOne(User, {
where: { id: 1 }
})
user.name = "Updated Name"
await transactionalEntityManager.save(user)
})
// 获取当前查询运行器的复制模式
const queryRunner = dataSource.createQueryRunner()
const currentMode = queryRunner.getReplicationMode()
故障转移与健康检查
TypeORM内置了完善的故障转移机制，确保系统的高可用性：
// 自定义健康检查中间件
const checkDatabaseHealth = async () => {
try {
const masterStatus = await dataSource.query("SELECT 1")
const slavesStatus = await Promise.allSettled(
dataSource.driver.replication.slaves.map(async (slave) => {
const slaveRunner = dataSource.createQueryRunner()
slaveRunner.mode = "slave"
return await slaveRunner.query("SELECT 1")
})
)
return {
master: masterStatus ? "healthy" : "unhealthy",
slaves: slavesStatus.map(status =>
status.status === "fulfilled" ? "healthy" : "unhealthy"
)
}
} catch (error) {
console.error("Database health check failed:", error)
return { master: "unhealthy", slaves: [] }
}
}
性能优化建议
在实际生产环境中，合理配置复制架构可以显著提升系统性能：
-
读写比例优化：根据应用的读写比例调整从库数量，通常读多写少的应用需要更多从库。
-
连接池配置：为不同角色的数据库实例配置独立的连接池参数：
// 主库连接池配置
const masterPoolConfig = {
connectionLimit: 20,
acquireTimeout: 60000,
timeout: 30000
}
// 从库连接池配置
const slavePoolConfig = {
connectionLimit: 50,
acquireTimeout: 30000,
timeout: 20000
}
-
监控与告警：实现完整的监控体系，实时跟踪各数据库节点的状态和性能指标。
-
数据一致性保障：在读写分离架构中，需要注意主从同步延迟可能导致的数据一致性问题，对于强一致性要求的场景可以采用适当的补偿机制。
通过TypeORM的复制与读写分离功能，开发者可以轻松构建高可用、高性能的数据库架构，为企业的业务发展提供坚实的技术支撑。这种架构不仅提升了系统的处理能力，还增强了系统的容错能力和可扩展性，是现代分布式系统不可或缺的重要组成部分。
总结
TypeORM提供了完整的企业级数据库连接管理解决方案，通过DataSource核心机制支持复杂多数据源场景，具备完善的连接池优化策略和事务管理能力。其内置的复制与读写分离功能能够有效提升系统性能和可用性，配合合理的配置监控体系，为现代分布式应用提供了稳定可靠的数据访问基础。掌握这些高级特性对于构建高性能、高可用的企业级应用至关重要。
创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考
