单体应用提高性能和处理高并发-数据库优化

最新推荐文章于 2024-08-08 22:28:47 发布

西可我偏偏是这款

最新推荐文章于 2024-08-08 22:28:47 发布

阅读量1k

点赞数 26

分类专栏：单体应用架构如何提高性能和处理高并发文章标签：数据库

本文链接：https://blog.csdn.net/chenkun_321/article/details/141036838

版权

单体应用架构如何提高性能和处理高并发专栏收录该内容

10 篇文章 0 订阅

订阅专栏

随便写写，希望能够帮到更多的小猿。也欢迎大佬指点。有生之年希望能见证国内知识不付费。

在单体应用中，数据库的优化是实现高并发的重要环节之一。高并发场景下，数据库常常成为瓶颈，导致系统响应时间变长，甚至引发服务不可用的情况。以下是详细的数据库优化策略，包括具体的实例。

话不多说，正文开始：

1. 优化数据库设计

1.1 规范化与反规范化

规范化：通过将数据分解为多个表来消除数据冗余，从而减少数据异常的可能性。常见的范式包括第一范式（1NF），第二范式（2NF），第三范式（3NF）等。

反规范化：为了提高查询性能，有时会故意增加冗余数据，减少联表查询。例如，将一些查询频繁的字段直接存储在一个表中，避免复杂的JOIN操作。

实例：假设你有一个订单系统，订单表和客户表是分开的，遵循第三范式。如果发现频繁需要查询订单和客户信息，可以将客户的一些关键信息（如姓名和联系方式）直接存储在订单表中。这种反规范化可以减少JOIN操作，提高查询速度。

-- 规范化设计
CREATE TABLE orders (
    order_id INT PRIMARY KEY,
    customer_id INT,
    order_date DATE,
    amount DECIMAL(10, 2),
    FOREIGN KEY (customer_id) REFERENCES customers(customer_id)
);

CREATE TABLE customers (
    customer_id INT PRIMARY KEY,
    customer_name VARCHAR(100),
    contact_info VARCHAR(100)
);

-- 反规范化设计
CREATE TABLE orders (
    order_id INT PRIMARY KEY,
    customer_id INT,
    customer_name VARCHAR(100), -- 反规范化字段
    contact_info VARCHAR(100),  -- 反规范化字段
    order_date DATE,
    amount DECIMAL(10, 2)
);

1.2 选择合适的数据类型

选择合适的数据类型可以有效减少存储空间和I/O操作。例如，在确定整数类型时，可以根据数据范围选择TINYINT、SMALLINT、INT或BIGINT。避免使用TEXT或BLOB类型，除非确实需要处理大量文本或二进制数据。

实例：

-- 如果订单金额最多为99999.99，使用DECIMAL(7, 2)即可
CREATE TABLE orders (
    order_id INT PRIMARY KEY,
    amount DECIMAL(7, 2) -- 精确控制金额的存储
);

2. 索引优化

2.1 合理使用索引

索引是提高查询性能的重要手段，但不合理的索引设计可能导致写入性能下降。索引的选择应基于查询的频率和复杂度，常见的索引类型包括B树索引、哈希索引和全文索引。

实例：假设你有一个用户表，经常按用户名和电子邮件查询用户信息。在这种情况下，你可以为用户名和电子邮件创建索引：

CREATE TABLE users (
    user_id INT PRIMARY KEY,
    username VARCHAR(50),
    email VARCHAR(100),
    password VARCHAR(100),
    created_at TIMESTAMP
);

-- 为 username 和 email 创建索引
CREATE INDEX idx_username ON users(username);
CREATE INDEX idx_email ON users(email);

2.2 复合索引

当查询涉及多个条件时，可以考虑使用复合索引。复合索引是对多个列的组合进行索引，能够加速包含这些列的查询。

实例：如果你经常需要根据用户名和创建时间查询用户，可以创建复合索引：

CREATE INDEX idx_username_created_at ON users(username, created_at);

在这个例子中，idx_username_created_at索引可以加速对username和created_at同时进行过滤的查询。

2.3 避免过多的索引

虽然索引可以提高查询性能，但每个索引都会增加数据库的存储开销，并在写入时带来额外的维护成本。应该根据实际需求权衡索引的数量。

3. 查询优化

3.1 使用解释计划分析查询

大多数数据库管理系统（如MySQL、PostgreSQL）提供了EXPLAIN命令来分析查询计划。通过分析查询计划，可以确定查询的执行方式，找出潜在的性能问题。

实例：

EXPLAIN SELECT * FROM orders WHERE customer_id = 123;

通过EXPLAIN命令，你可以看到数据库如何执行查询，以及是否使用了索引。根据分析结果，可以对查询进行优化。

3.2 **减少SELECT * 操作**

SELECT *会返回表中的所有列，可能会导致不必要的数据传输。应该只选择所需的列，以减少I/O开销。

实例：

-- 避免
SELECT * FROM orders WHERE customer_id = 123;

-- 优化
SELECT order_id, order_date, amount FROM orders WHERE customer_id = 123;

3.3 优化JOIN操作

JOIN操作通常是性能瓶颈，应尽量减少JOIN的次数或通过适当的索引优化JOIN操作。

实例：

-- 假设你有一个订单表和一个产品表
SELECT o.order_id, p.product_name
FROM orders o
JOIN products p ON o.product_id = p.product_id
WHERE o.customer_id = 123;

-- 可以为product_id列创建索引来优化JOIN操作
CREATE INDEX idx_product_id ON products(product_id);

4. 缓存查询结果

4.1 使用应用级缓存

在高并发场景下，频繁的数据库查询会导致数据库压力增大。通过在应用层使用缓存，可以减少对数据库的直接访问。常见的缓存方案有Redis、Memcached等。

实例：假设你有一个网站，需要频繁查询某个产品的详细信息。可以将查询结果缓存到Redis中，减少数据库的访问次数。

// Java 代码示例，使用Redis缓存查询结果
Jedis jedis = new Jedis("localhost");

// 先从缓存中获取数据
String product = jedis.get("product:123");
if (product == null) {
    // 如果缓存中没有，查询数据库
    product = queryProductFromDatabase(123);
    // 将结果放入缓存
    jedis.set("product:123", product);
}

4.2 使用数据库内部缓存

许多数据库管理系统本身也提供了查询缓存功能。例如，MySQL具有查询缓存，可以将查询结果缓存到内存中，减少相同查询的执行时间。

实例：在MySQL中，可以通过以下命令启用查询缓存：

SET GLOBAL query_cache_size = 1048576; -- 设置缓存大小为1MB
SET GLOBAL query_cache_type = ON; -- 启用查询缓存

5. 分区与分表

5.1 水平分区（Sharding）

在单表数据量非常大的情况下，可以将表进行水平分区，即将表的数据按某个规则（如按用户ID、日期等）拆分到多个表或数据库中。这样可以减少单个表的大小，提高查询性能。

实例：假设你有一个大订单表，可以按年份对表进行分区：

CREATE TABLE orders_2023 LIKE orders;
CREATE TABLE orders_2024 LIKE orders;

-- 将2023年的订单插入orders_2023表，2024年的订单插入orders_2024表
INSERT INTO orders_2023 SELECT * FROM orders WHERE YEAR(order_date) = 2023;
INSERT INTO orders_2024 SELECT * FROM orders WHERE YEAR(order_date) = 2024;

5.2 垂直分区

垂直分区是将表的列拆分为多个表。例如，可以将一些不常用的列或较大的BLOB字段单独放入一个表中，从而减少主表的大小，提高查询性能。

实例：

-- 原始表
CREATE TABLE users (
    user_id INT PRIMARY KEY,
    username VARCHAR(50),
    email VARCHAR(100),
    bio TEXT,
    profile_picture BLOB
);

-- 垂直分区后
CREATE TABLE users (
    user_id INT PRIMARY KEY,
    username VARCHAR(50),
    email VARCHAR(100)
);

CREATE TABLE user_profiles (
    user_id INT PRIMARY KEY,
    bio TEXT,
    profile_picture BLOB,
    FOREIGN KEY (user_id) REFERENCES users(user_id)
);

6. 读写分离

在高并发的应用中，可以将读操作和写操作分离，通过主从复制实现读写分离。主数据库负责写操作，从数据库负责读操作，这样可以有效地分担数据库的负载。

实例：假设你有一个电商应用，用户下单时将订单数据写入主数据库，而商品详情、订单查询等读取操作则从从数据库读取。

伪代码示例：

// 获取数据库连接
Database masterDb = getMasterDatabase(); // 主数据库用于写操作
Database slaveDb = getSlaveDatabase();   // 从数据库用于读操作

// 写操作：将订单插入主数据库
masterDb.execute("INSERT INTO orders (order_id, customer_id, product_id, amount) VALUES (1, 123, 456, 789.00)");

// 读操作：从从数据库中查询订单详情
ResultSet rs = slaveDb.executeQuery("SELECT * FROM orders WHERE order_id = 1");

在此示例中，写操作通过主数据库完成，读操作则通过从数据库完成。这样可以有效地减少主数据库的压力，提升系统的读写性能。

7. 连接池的使用

7.1 数据库连接池的概念

数据库连接池是用于管理数据库连接的对象池。连接池能够在应用程序启动时创建并维护一定数量的数据库连接，这些连接可以被反复使用，而不必为每次请求都建立和销毁连接。这减少了数据库连接的开销，显著提升了高并发场景下的性能。

常用的数据库连接池包括：

HikariCP：一个高性能的JDBC连接池，广泛用于Java应用中。

C3P0：一个健壮、简单的连接池实现，支持JDBC 3和JDBC 4。

DBCP（Database Connection Pooling）：Apache Commons 提供的连接池实现，功能强大，配置灵活。

7.2 HikariCP连接池配置

以下是HikariCP连接池在Java中的配置示例：

Java代码示例：

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;

public class HikariCPExample {
    public static void main(String[] args) throws Exception {
        // 配置HikariCP
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:mysql://localhost:3306/yourdatabase");
        config.setUsername("yourusername");
        config.setPassword("yourpassword");
        config.setMaximumPoolSize(10); // 设置最大连接数

        // 创建数据源
        HikariDataSource dataSource = new HikariDataSource(config);

        // 获取连接并执行查询
        try (Connection connection = dataSource.getConnection()) {
            Statement stmt = connection.createStatement();
            ResultSet rs = stmt.executeQuery("SELECT * FROM orders");
            while (rs.next()) {
                System.out.println("Order ID: " + rs.getInt("order_id"));
            }
        }

        // 关闭数据源
        dataSource.close();
    }
}

8. 异步与批量处理

8.1 异步操作

在高并发场景中，将某些不需要实时处理的操作转为异步执行可以极大地减轻数据库的瞬时压力。例如，用户行为日志、订单处理等操作可以通过异步队列来处理。

实例：

假设你有一个在线商店，当用户下单时，你可以将订单处理放到队列中，并通过后台任务进行异步处理。

伪代码示例：

// 使用队列保存订单处理任务
OrderQueue queue = new OrderQueue();

// 当用户下单时，将订单处理任务添加到队列
queue.add(new OrderProcessingTask(order));

// 异步处理订单
new Thread(() -> {
    while (true) {
        OrderProcessingTask task = queue.poll();
        if (task != null) {
            task.process();
        }
    }
}).start();

8.2 批量处理

在需要对数据库进行多次写操作时，可以将这些操作批量执行，这样可以减少数据库的I/O开销，并提高写入效率。批量操作可以显著减少网络传输和磁盘I/O的次数。

实例：

假设你需要批量插入用户数据，可以使用JDBC的批处理功能：

Java代码示例：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;

public class BatchInsertExample {
    public static void main(String[] args) throws Exception {
        // 获取数据库连接
        Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/yourdatabase", "yourusername", "yourpassword");

        // 关闭自动提交模式
        connection.setAutoCommit(false);

        // 准备SQL语句
        String sql = "INSERT INTO users (username, email) VALUES (?, ?)";
        PreparedStatement pstmt = connection.prepareStatement(sql);

        // 批量插入用户数据
        for (int i = 0; i < 1000; i++) {
            pstmt.setString(1, "user" + i);
            pstmt.setString(2, "user" + i + "@example.com");
            pstmt.addBatch();

            // 每100条提交一次
            if (i % 100 == 0) {
                pstmt.executeBatch();
                connection.commit();
            }
        }

        // 提交剩余的批量操作
        pstmt.executeBatch();
        connection.commit();

        // 关闭连接
        pstmt.close();
        connection.close();
    }
}

在上述代码中，通过将INSERT操作批量执行，可以显著提高插入效率，并减少事务提交的次数。

9. 数据库分区和分库

9.1 分区表

在单表数据量过大的情况下，使用数据库分区可以有效地提高查询和写入性能。分区表可以按某个字段（如时间、用户ID等）将数据分割到多个物理文件中，从而减少单个分区的查询开销。

实例：假设你有一个日志表，需要存储大量日志数据，可以按月份进行分区：

SQL示例：

CREATE TABLE logs (
    log_id INT PRIMARY KEY,
    log_message TEXT,
    log_date DATE
) PARTITION BY RANGE (YEAR(log_date)) (
    PARTITION p2023 VALUES LESS THAN (2024),
    PARTITION p2024 VALUES LESS THAN (2025)
);

9.2 分库

当单个数据库的性能无法满足需求时，可以将数据拆分到多个数据库中（分库）。这通常涉及将数据按某个规则（如用户ID）拆分到不同的数据库实例中，以平衡负载。

实例：

假设你有一个电商平台，用户数据和订单数据可以分别存储在不同的数据库中：

伪代码示例：

// 根据用户ID选择数据库
Database userDb = getDatabaseForUser(userId);

// 根据订单ID选择数据库
Database orderDb = getDatabaseForOrder(orderId);

10. 读写分离与数据库复制

在高并发环境下，通过读写分离和数据库复制，可以有效分担数据库的读写压力，保证系统的高可用性。

10.1 读写分离

通过将写操作定向到主数据库，将读操作定向到从数据库，能够实现读写分离，从而提高系统的并发处理能力。

实例：在MySQL中，可以通过配置主从复制来实现读写分离：

MySQL主从复制配置：

主数据库：配置binlog并允许从数据库连接。

从数据库：配置连接主数据库，并同步数据。

伪代码示例：

// 写操作：主数据库
Database masterDb = getMasterDatabase();
masterDb.execute("INSERT INTO orders (...) VALUES (...)");

// 读操作：从数据库
Database slaveDb = getSlaveDatabase();
ResultSet rs = slaveDb.executeQuery("SELECT * FROM orders WHERE ...");