428 lines
16 KiB
JavaScript
428 lines
16 KiB
JavaScript
/**
|
|
* 数据库连接和操作类
|
|
* 提供 PostgreSQL 数据库的连接池和基础操作方法
|
|
*/
|
|
|
|
const { Pool } = require('pg');
|
|
const winston = require('winston');
|
|
require('dotenv').config();
|
|
|
|
class DatabaseManager {
|
|
constructor() {
|
|
this.pool = null;
|
|
this.logger = winston.createLogger({
|
|
level: process.env.LOG_LEVEL || 'info',
|
|
format: winston.format.combine(
|
|
winston.format.timestamp(),
|
|
winston.format.errors({ stack: true }),
|
|
winston.format.json()
|
|
),
|
|
transports: [
|
|
new winston.transports.Console(),
|
|
new winston.transports.File({ filename: 'logs/database.log' })
|
|
]
|
|
});
|
|
|
|
this.initializePool();
|
|
}
|
|
|
|
/**
|
|
* 初始化数据库连接池
|
|
*/
|
|
initializePool() {
|
|
try {
|
|
this.pool = new Pool({
|
|
host: process.env.DB_HOST || 'localhost',
|
|
port: process.env.DB_PORT || 5432,
|
|
database: process.env.DB_NAME || 'push_messages',
|
|
user: process.env.DB_USER || 'push_service',
|
|
password: process.env.DB_PASSWORD,
|
|
ssl: process.env.DB_SSL === 'true',
|
|
max: parseInt(process.env.DB_MAX_CONNECTIONS) || 20,
|
|
idleTimeoutMillis: parseInt(process.env.DB_IDLE_TIMEOUT) || 30000,
|
|
connectionTimeoutMillis: parseInt(process.env.DB_CONNECTION_TIMEOUT) || 5000,
|
|
});
|
|
|
|
// 监听连接池事件
|
|
this.pool.on('connect', (client) => {
|
|
this.logger.info('数据库连接已建立', {
|
|
totalCount: this.pool.totalCount,
|
|
idleCount: this.pool.idleCount,
|
|
waitingCount: this.pool.waitingCount
|
|
});
|
|
});
|
|
|
|
this.pool.on('error', (err, client) => {
|
|
this.logger.error('数据库连接池错误', { error: err.message, stack: err.stack });
|
|
});
|
|
|
|
this.logger.info('数据库连接池初始化完成');
|
|
|
|
} catch (error) {
|
|
this.logger.error('数据库连接池初始化失败', { error: error.message, stack: error.stack });
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 测试数据库连接
|
|
*/
|
|
async testConnection() {
|
|
try {
|
|
const client = await this.pool.connect();
|
|
const result = await client.query('SELECT NOW() as current_time, version() as version');
|
|
client.release();
|
|
|
|
this.logger.info('数据库连接测试成功', {
|
|
currentTime: result.rows[0].current_time,
|
|
version: result.rows[0].version.split(' ')[0]
|
|
});
|
|
|
|
return {
|
|
success: true,
|
|
currentTime: result.rows[0].current_time,
|
|
version: result.rows[0].version
|
|
};
|
|
} catch (error) {
|
|
this.logger.error('数据库连接测试失败', { error: error.message, stack: error.stack });
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 插入推送消息
|
|
*/
|
|
async insertPushMessage(messageData) {
|
|
const startTime = Date.now();
|
|
const client = await this.pool.connect();
|
|
|
|
try {
|
|
await client.query('BEGIN');
|
|
|
|
// 生成消息校验和用于去重
|
|
const checksum = this.generateChecksum(messageData);
|
|
|
|
// 检查是否存在重复消息
|
|
const duplicateCheck = await client.query(
|
|
'SELECT id FROM push_messages WHERE checksum = $1 AND is_deleted = FALSE LIMIT 1',
|
|
[checksum]
|
|
);
|
|
|
|
let messageId;
|
|
let isDuplicate = false;
|
|
|
|
if (duplicateCheck.rows.length > 0) {
|
|
// 处理重复消息
|
|
isDuplicate = true;
|
|
const originalMessageId = duplicateCheck.rows[0].id;
|
|
|
|
const insertQuery = `
|
|
INSERT INTO push_messages (
|
|
message_id, push_type, user_id, device_id, source_ip, user_agent,
|
|
raw_data, parsed_data, priority, category, tags, checksum,
|
|
is_duplicate, original_message_id, latitude, longitude,
|
|
location_accuracy, location_timestamp
|
|
) VALUES (
|
|
$1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18
|
|
) RETURNING id
|
|
`;
|
|
|
|
const result = await client.query(insertQuery, [
|
|
messageData.message_id || null,
|
|
messageData.push_type || messageData.pushType,
|
|
messageData.user_id || messageData.userId,
|
|
messageData.device_id || messageData.deviceId,
|
|
messageData.source_ip,
|
|
messageData.user_agent,
|
|
JSON.stringify(messageData.raw_data || messageData),
|
|
JSON.stringify(messageData.parsed_data || messageData),
|
|
messageData.priority || 5,
|
|
messageData.category,
|
|
messageData.tags,
|
|
checksum,
|
|
true,
|
|
originalMessageId,
|
|
messageData.latitude || messageData.lat,
|
|
messageData.longitude || messageData.lng,
|
|
messageData.location_accuracy || messageData.accuracy,
|
|
messageData.location_timestamp || null
|
|
]);
|
|
|
|
messageId = result.rows[0].id;
|
|
|
|
} else {
|
|
// 插入新消息
|
|
const insertQuery = `
|
|
INSERT INTO push_messages (
|
|
message_id, push_type, user_id, device_id, source_ip, user_agent,
|
|
raw_data, parsed_data, priority, category, tags, checksum,
|
|
is_duplicate, latitude, longitude, location_accuracy, location_timestamp
|
|
) VALUES (
|
|
$1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17
|
|
) RETURNING id
|
|
`;
|
|
|
|
const result = await client.query(insertQuery, [
|
|
messageData.message_id || null,
|
|
messageData.push_type || messageData.pushType,
|
|
messageData.user_id || messageData.userId,
|
|
messageData.device_id || messageData.deviceId,
|
|
messageData.source_ip,
|
|
messageData.user_agent,
|
|
JSON.stringify(messageData.raw_data || messageData),
|
|
JSON.stringify(messageData.parsed_data || messageData),
|
|
messageData.priority || 5,
|
|
messageData.category,
|
|
messageData.tags,
|
|
checksum,
|
|
false,
|
|
messageData.latitude || messageData.lat,
|
|
messageData.longitude || messageData.lng,
|
|
messageData.location_accuracy || messageData.accuracy,
|
|
messageData.location_timestamp || null
|
|
]);
|
|
|
|
messageId = result.rows[0].id;
|
|
}
|
|
|
|
// 记录处理日志
|
|
await client.query(
|
|
`INSERT INTO message_processing_logs (message_id, processing_step, status, started_at, completed_at, duration_ms, details)
|
|
VALUES ($1, $2, $3, $4, $5, $6, $7)`,
|
|
[
|
|
messageId,
|
|
'message_received',
|
|
'completed',
|
|
new Date(startTime),
|
|
new Date(),
|
|
Date.now() - startTime,
|
|
JSON.stringify({ isDuplicate, checksum })
|
|
]
|
|
);
|
|
|
|
// 更新设备信息
|
|
if (messageData.device_id || messageData.deviceId) {
|
|
await this.upsertDevice(client, {
|
|
device_id: messageData.device_id || messageData.deviceId,
|
|
device_name: messageData.device_name,
|
|
device_type: messageData.device_type,
|
|
user_id: messageData.user_id || messageData.userId,
|
|
metadata: messageData.device_metadata
|
|
});
|
|
}
|
|
|
|
// 更新用户信息
|
|
if (messageData.user_id || messageData.userId) {
|
|
await this.upsertUser(client, {
|
|
user_id: messageData.user_id || messageData.userId,
|
|
user_name: messageData.user_name,
|
|
user_type: messageData.user_type
|
|
});
|
|
}
|
|
|
|
await client.query('COMMIT');
|
|
|
|
this.logger.info('推送消息插入成功', {
|
|
messageId,
|
|
pushType: messageData.push_type || messageData.pushType,
|
|
userId: messageData.user_id || messageData.userId,
|
|
isDuplicate,
|
|
processingTime: Date.now() - startTime
|
|
});
|
|
|
|
return {
|
|
success: true,
|
|
messageId,
|
|
isDuplicate,
|
|
processingTime: Date.now() - startTime
|
|
};
|
|
|
|
} catch (error) {
|
|
await client.query('ROLLBACK');
|
|
this.logger.error('推送消息插入失败', { error: error.message, stack: error.stack });
|
|
throw error;
|
|
} finally {
|
|
client.release();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 批量插入推送消息
|
|
*/
|
|
async insertPushMessagesBatch(messagesData) {
|
|
const startTime = Date.now();
|
|
const client = await this.pool.connect();
|
|
|
|
try {
|
|
await client.query('BEGIN');
|
|
|
|
const results = [];
|
|
|
|
for (const messageData of messagesData) {
|
|
try {
|
|
const result = await this.insertPushMessage(messageData);
|
|
results.push(result);
|
|
} catch (error) {
|
|
results.push({
|
|
success: false,
|
|
error: error.message,
|
|
messageData: messageData
|
|
});
|
|
}
|
|
}
|
|
|
|
await client.query('COMMIT');
|
|
|
|
const successCount = results.filter(r => r.success).length;
|
|
const failureCount = results.filter(r => !r.success).length;
|
|
|
|
this.logger.info('批量推送消息插入完成', {
|
|
totalCount: messagesData.length,
|
|
successCount,
|
|
failureCount,
|
|
processingTime: Date.now() - startTime
|
|
});
|
|
|
|
return {
|
|
success: true,
|
|
totalCount: messagesData.length,
|
|
successCount,
|
|
failureCount,
|
|
results,
|
|
processingTime: Date.now() - startTime
|
|
};
|
|
|
|
} catch (error) {
|
|
await client.query('ROLLBACK');
|
|
this.logger.error('批量推送消息插入失败', { error: error.message, stack: error.stack });
|
|
throw error;
|
|
} finally {
|
|
client.release();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 更新或插入设备信息
|
|
*/
|
|
async upsertDevice(client, deviceData) {
|
|
const query = `
|
|
INSERT INTO devices (device_id, device_name, device_type, user_id, last_seen_at, metadata)
|
|
VALUES ($1, $2, $3, $4, CURRENT_TIMESTAMP, $5)
|
|
ON CONFLICT (device_id)
|
|
DO UPDATE SET
|
|
device_name = COALESCE(EXCLUDED.device_name, devices.device_name),
|
|
device_type = COALESCE(EXCLUDED.device_type, devices.device_type),
|
|
user_id = COALESCE(EXCLUDED.user_id, devices.user_id),
|
|
last_seen_at = CURRENT_TIMESTAMP,
|
|
metadata = COALESCE(EXCLUDED.metadata, devices.metadata),
|
|
updated_at = CURRENT_TIMESTAMP
|
|
`;
|
|
|
|
await client.query(query, [
|
|
deviceData.device_id,
|
|
deviceData.device_name,
|
|
deviceData.device_type,
|
|
deviceData.user_id,
|
|
JSON.stringify(deviceData.metadata || {})
|
|
]);
|
|
}
|
|
|
|
/**
|
|
* 更新或插入用户信息
|
|
*/
|
|
async upsertUser(client, userData) {
|
|
const query = `
|
|
INSERT INTO users (user_id, user_name, user_type)
|
|
VALUES ($1, $2, $3)
|
|
ON CONFLICT (user_id)
|
|
DO UPDATE SET
|
|
user_name = COALESCE(EXCLUDED.user_name, users.user_name),
|
|
user_type = COALESCE(EXCLUDED.user_type, users.user_type),
|
|
updated_at = CURRENT_TIMESTAMP
|
|
`;
|
|
|
|
await client.query(query, [
|
|
userData.user_id,
|
|
userData.user_name,
|
|
userData.user_type
|
|
]);
|
|
}
|
|
|
|
/**
|
|
* 生成消息校验和
|
|
*/
|
|
generateChecksum(data) {
|
|
const crypto = require('crypto');
|
|
const normalizedData = JSON.stringify(data, Object.keys(data).sort());
|
|
return crypto.createHash('sha256').update(normalizedData).digest('hex');
|
|
}
|
|
|
|
/**
|
|
* 获取消息统计信息
|
|
*/
|
|
async getMessageStats(hoursBack = 24) {
|
|
try {
|
|
const query = 'SELECT * FROM get_message_stats($1)';
|
|
const result = await this.pool.query(query, [hoursBack]);
|
|
return result.rows;
|
|
} catch (error) {
|
|
this.logger.error('获取消息统计失败', { error: error.message, stack: error.stack });
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 获取系统健康状态
|
|
*/
|
|
async getHealthStatus() {
|
|
try {
|
|
const poolStats = {
|
|
totalCount: this.pool.totalCount,
|
|
idleCount: this.pool.idleCount,
|
|
waitingCount: this.pool.waitingCount
|
|
};
|
|
|
|
const dbStats = await this.pool.query(`
|
|
SELECT
|
|
COUNT(*) as total_messages,
|
|
COUNT(*) FILTER (WHERE received_at >= CURRENT_TIMESTAMP - INTERVAL '1 hour') as messages_last_hour,
|
|
COUNT(*) FILTER (WHERE processing_status = 'pending') as pending_messages,
|
|
COUNT(*) FILTER (WHERE processing_status = 'failed') as failed_messages
|
|
FROM push_messages
|
|
WHERE is_deleted = FALSE
|
|
`);
|
|
|
|
return {
|
|
database: {
|
|
connected: true,
|
|
pool: poolStats,
|
|
stats: dbStats.rows[0]
|
|
},
|
|
timestamp: new Date().toISOString()
|
|
};
|
|
|
|
} catch (error) {
|
|
this.logger.error('获取系统健康状态失败', { error: error.message, stack: error.stack });
|
|
return {
|
|
database: {
|
|
connected: false,
|
|
error: error.message
|
|
},
|
|
timestamp: new Date().toISOString()
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 关闭数据库连接池
|
|
*/
|
|
async close() {
|
|
if (this.pool) {
|
|
await this.pool.end();
|
|
this.logger.info('数据库连接池已关闭');
|
|
}
|
|
}
|
|
}
|
|
|
|
module.exports = DatabaseManager;
|