1. 首页
  2. 分类
  3. 后端技术
SqlSugar框架连接达梦主备实现高可用及解决程序高并发条件下与数据库断连的方法
System
2024-09-03
所有,数据库



// 使用SqlSugar框架配置达梦数据库的高可用方案
public class SqlSugarDbContext
{
    private static SqlSugarClient db;
 
    // 单例模式确保全局只有一个实例
    public static SqlSugarClient Instance
    {
        get
        {
            if (db == null)
            {
                // 配置主库
                ConnectionConfig config = new ConnectionConfig()
                {
                    ConnectionString = "主库连接字符串",
                    DbType = DbType.Dm,
                    IsAutoCloseConnection = true,
                    InitKeyType = InitKeyType.Attribute
                };
 
                // 配置备库
                List<IClient> slaveClients = new List<IClient>
                {
                    new SqlSugarClient(new ConnectionConfig()
                    {
                        ConnectionString = "备库1连接字符串",
                        DbType = DbType.Dm,
                        IsAutoCloseConnection = true,
                        InitKeyType = InitKeyType.Attribute
                    }),
                    new SqlSugarClient(new ConnectionConfig()
                    {
                        ConnectionString = "备库2连接字符串",
                        DbType = DbType.Dm,
                        IsAutoCloseConnection = true,
                        InitKeyType = InitKeyType.Attribute
                    })
                };
 
                // 实例化SqlSugarClient并配置高可用
                db = new SqlSugarClient(new ClientInfo()
                {
                    IsAutoCloseConnection = true,
                    MasterDbConfig = config,
                    SlaveDbs = slaveClients
                });
            }
            return db;
        }
    }
 
    // 自定义高并发条件下的数据库重连机制
    public static void Reconnect()
    {
        var reconnectTimes = 0;
        while (true)
        {
            try
            {
                using (var db = Instance)
- 阅读更多 -
SpringCloud Alibaba——Ribbon的属性配置和类配置优先级
System
2024-09-03
所有,java

在Spring Cloud Alibaba中，使用Ribbon进行服务调用时，可以通过配置文件和编程的方式来配置Ribbon的属性。

配置文件的优先级高于编程的配置，因此如果同时配置了属性，优先使用配置文件中的配置。

以下是一些常见的Ribbon配置属性示例：

  1. 配置连接超时时间和读取超时时间：



ribbon.ConnectTimeout=1000
ribbon.ReadTimeout=3000
  1. 配置重试策略：



ribbon.MaxAutoRetries=2
ribbon.MaxAutoRetriesNextServer=1
  1. 配置服务列表更新间隔：



ribbon.ServerListRefreshInterval=30000
  1. 配置服务调用的规则（如顺序、随机等）：



ribbon.NFLoadBalancerRuleClassName=com.netflix.loadbalancer.RandomRule

在编程的方式中，可以使用@Bean注解来覆盖Ribbon默认的配置，如下所示：




@Bean
public IRule ribbonRule() {
    return new RandomRule(); // 使用随机策略
}

如果同时在配置文件和编程方式中配置了相同的属性，优先使用配置文件中的配置。

- 阅读更多 -
如何监控和分析 PostgreSQL 中的查询执行计划？
System
2024-09-03
所有,数据库

在PostgreSQL中，可以使用EXPLAIN或EXPLAIN ANALYZE命令来查看查询的执行计划。EXPLAIN会显示查询计划，但不实际执行查询；EXPLAIN ANALYZE会执行查询并显示实际的执行计划和统计信息。

例如：




EXPLAIN SELECT * FROM your_table WHERE your_column = 'your_value';

或者：




EXPLAIN ANALYZE SELECT * FROM your_table WHERE your_column = 'your_value';

如果需要持续监控和分析查询性能，可以使用pg_stat_statements扩展。首先需要启用和配置该扩展：

  1. 确保pg_stat_statements模块在PostgreSQL中可用。
  2. 在postgresql.conf中启用：



shared_preload_libraries = 'pg_stat_statements'
  1. 设置追踪的语句数量：



pg_stat_statements.max = 1000
  1. 重新启动PostgreSQL服务器以应用更改。
  2. 创建pg_stat_statements扩展：



CREATE EXTENSION pg_stat_statements;

启用后，可以查询pg_stat_statements视图来查看统计数据：




SELECT * FROM pg_stat_statements;

这将显示所有已记录的查询及其执行计划和统计信息，如执行次数、总执行时间、行数、共享区块读取次数等。

- 阅读更多 -
深入理解@RequestParam注解：Spring MVC参数绑定的利器
System
2024-09-03
所有,java



import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
public class ParameterController {
 
    // 使用@RequestParam绑定请求参数到方法参数
    @RequestMapping("/greeting")
    public String greeting(@RequestParam(name = "name", defaultValue = "World") String name) {
        return "Hello, " + name + "!";
    }
}

这段代码定义了一个简单的Spring MVC控制器，其中包含一个使用@RequestParam注解的方法。该方法通过映射/greeting路径，将请求中名为name的参数绑定到方法参数上。如果没有提供name参数，它会使用默认值World。这个例子展示了如何使用@RequestParam来简化参数获取和方法签名定义的过程。

- 阅读更多 -
redis存储结构
System
2024-09-03
所有,redis

Redis 是一个开源的使用 C 语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value 数据库，并提供多种语言的 API。

Redis 存储结构主要有以下几种类型：

  1. String：字符串类型是 Redis 最基本的数据类型，可以理解为与 Memcached 一模一样的类型，一个 key 对应一个 value。

    实例代码：

    


# 设置 key-value
set('key', 'value')
# 获取 key 对应的 value
get('key')

  2. List：列表类型，Redis 的列表是有序的，我们可以从两端进行插入和删除操作。

    实例代码：

    


# 从列表右端插入一个元素
rpush('list_key', 'value')
# 从列表左端插入一个元素
lpush('list_key', 'value')
# 获取列表的全部元素
lrange('list_key', 0, -1)

  3. Set：集合类型，和列表类型不同，集合中的元素都是不重复的。

    实例代码：

    


# 添加一个元素到集合
sadd('set_key', 'value')
# 获取集合中的所有元素
smembers('set_key')

  4. Hash：哈希类型，可以理解为一个 key-value 的集合。

    实例代码：

    


# 设置哈希表中的字段的值
hset('hash_key', 'field', 'value')
# 获取哈希表中的所有字段和值
hgetall('hash_key')

  5. Zset（Sorted Set）：有序集合类型，是集合类型的一个升级版，它在集合的基础上增加了一个顺序属性，其每个元素都关联着一个顺序值。

    实例代码：

    


# 添加一个元素到有序集合
zadd('zset_key', {'value': score})
# 获取有序集合中的所有元素
zrange('zset_key', 0, -1)

以上就是 Redis 的主要存储结构和对应的实例代码。在实际应用中，可以根据需要选择合适的数据类型和操作命令。

- 阅读更多 -
基于 Redis 的分布式锁 Spring Boot 集成 Redisson 使用分布式锁确保对共享资源的互斥访问
System
2024-09-03
所有,redis

在Spring Boot项目中，可以使用Redisson提供的分布式锁来确保对共享资源的同步访问。以下是一个使用Redisson实现分布式锁的示例：

  1. 首先，在pom.xml中添加Redisson的依赖：



<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.16.2</version>
</dependency>
  1. 在application.yml或application.properties中配置Redisson连接：



spring:
  redisson:
    address: redis://127.0.0.1:6379
    password: your_password
  1. 在Spring Boot应用中使用Redisson提供的分布式锁：



import org.redisson.api.RedissonClient;
import org.redisson.api.RLock;
 
@Service
public class DistributedLockService {
 
    @Autowired
    private RedissonClient redissonClient;
 
    public void lockAndExecute(String lockKey, Runnable runnable) {
        RLock lock = redissonClient.getLock(lockKey);
        try {
            // 尝试获取锁，最多等待100秒，锁在10秒后自动释放
            boolean isLocked = lock.tryLock(100, 10, TimeUnit.SECONDS);
            if (isLocked) {
                runnable.run();
            } else {
                // 如果未能获取锁，执行其他逻辑或者直接返回
                System.out.println("无法获取锁，操作被跳过。");
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }
}

在这个示例中，DistributedLockService提供了一个方法lockAndExecute，它尝试获取一个分布式锁，并在获取锁后执行传入的Runnable任务。如果无法在指定时间内获取锁，则会执行其他逻辑或直接返回。最后，在finally块中释放锁，确保即使发生异常也能正确释放锁。

- 阅读更多 -
FastAPI集成mongodb事务处理
System
2024-09-03
所有,数据库

在FastAPI中，要实现对MongoDB的事务处理，你需要使用MongoDB的事务功能，并结合FastAPI的依赖注入系统。以下是一个简化的例子，展示如何在FastAPI中集成MongoDB的事务处理：

首先，确保你的MongoDB服务器支持事务，并且在你的项目中安装了motor库，它是一个基于异步的MongoDB驱动。




pip install motor

然后，在你的FastAPI应用中设置数据库连接和事务处理的逻辑：




from fastapi import FastAPI, Depends
from motor.motor_asyncio import AsyncIOMotorClient
from starlette.exceptions import HTTPException
 
app = FastAPI()
 
# 假设你已经有了一个MongoDB实例并且启用了事务支持
client = AsyncIOMotorClient("mongodb://localhost:27017")
database = client.your_database
 
async def get_database():
    return database
 
async def get_collection(collection_name: str):
    return database[collection_name]
 
# 事务处理的依赖项
async def transaction(fn):
    async with database.client.start_session() as session:
        with session.start_transaction():
            result = await fn(session)
    return result
 
# 示例路由，使用事务处理
@app.post("/transaction-example/")
async def transaction_example(data: dict, collection=Depends(get_collection("your_collection"))):
    async with database.client.start_session() as session:
        with session.start_transaction():
            # 在这里执行你的数据库操作
            await collection.insert_one(data, session=session)
            # 如果需要，可以继续添加更多操作
            # ...
            # 如果操作成功，会自动提交事务
            # 如果抛出异常，会自动回滚事务
 
# 启动应用
if __name__ == "__main__":
    import asyncio
    asyncio.run(database.client.server_info())
    uvicorn.run(app, host="0.0.0.0", port=8000)

在这个例子中，我们定义了一个get_database和get_collection依赖项，它们返回数据库和集合的引用。transaction函数是一个高阶依赖项，它使用MongoDB的会话和事务处理来执行传入的函数。在transaction_example路由中，我们使用start_transaction来确保一系列的数据库操作要么全部成功，要么全部失败。

请注意，这个例子假设你已经有了一个运行中的MongoDB实例，并且该实例已经启用了对事务的支持。在实际部署时，你可能需要根据你的MongoDB设置来调整连接字符串和其他配置。

- 阅读更多 -
记录一次Redis链接池超MaxConnection&链接不释放问题
System
2024-09-03
所有,redis

解释：

MaxConnection错误通常表示Redis链接池中已达到最大连接数，新的连接请求无法被满足，因为所有的连接都在使用中。这可能是因为应用程序没有正确关闭Redis连接，导致连接泄露。

解决方法：

  1. 检查代码：确保在使用完Redis后正确关闭连接。如果是使用连接池，确保返回连接到池中，而不是直接关闭。
  2. 调整配置：增加Redis连接池的最大连接数，以便应对高峰期需求。
  3. 监控：实施监控系统，以便在达到最大连接数时收到警告。
  4. 优化：优化应用程序逻辑，减少不必要的Redis连接，或者使用更有效的连接管理策略。

示例代码（以Python的redis-py库为例）：




from redis import Redis, ConnectionPool
 
pool = ConnectionPool(host='localhost', port=6379, max_connections=10)
redis = Redis(connection_pool=pool)
 
try:
    # 使用Redis
    pass
finally:
    # 确保连接被释放回连接池，而不是关闭
    redis.close()

确保在finally块中关闭连接，或者使用上下文管理器来自动管理连接的生命周期。

- 阅读更多 -
嵌入式数据库sqlite3【基础篇】基本命令操作，小白一看就懂（C/C++）
System
2024-09-03
所有,数据库



#include <stdio.h>
#include <stdlib.h>
#include <sqlite3.h>
 
static int callback(void *NotUsed, int argc, char **argv, char **azColName) {
    for (int i = 0; i < argc; i++) {
        printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
    }
    printf("\n");
    return 0;
}
 
int main() {
    sqlite3 *db;
    char *zErrMsg = 0;
    int rc;
 
    rc = sqlite3_open("example.db", &db);
    if (rc) {
        fprintf(stderr, "无法打开数据库: %s\n", sqlite3_errmsg(db));
        sqlite3_close(db);
        exit(0);
    } else {
        fprintf(stdout, "数据库打开成功\n");
    }
 
    // 创建一个表
    char *sql = "CREATE TABLE IF NOT EXISTS students(id integer, name text, score integer);";
    rc = sqlite3_exec(db, sql, callback, 0, &zErrMsg);
    if (rc != SQLITE_OK) {
        fprintf(stderr, "SQL错误: %s\n", zErrMsg);
        sqlite3_free(zErrMsg);
    } else {
        fprintf(stdout, "表创建成功\n");
    }
 
    // 插入数据
    sql = "INSERT INTO students(id, name, score) VALUES(1, '小明', 95);";
    rc = sqlite3_exec(db, sql, callback, 0, &zErrMsg);
    if (rc != SQLITE_OK) {
        fprintf(stderr, "SQL错误: %s\n", zErrMsg);
        sqlite3_free(zErrMsg);
    } else {
        fprintf(stdout, "数据插入成功\n");
    }
 
    // 查询数据
    sql = "SELECT * FROM students;";
    rc = sqlite3_exec(db, sql, callback, 0, &zErrMsg);
    if (rc != SQLITE_OK) {
        fprintf(stderr, "SQL错误: %s\n", zErrMsg);
        sqlite3_free(zErrMsg);
    } else {
        fprintf(stdout, "查询成功\n");
    }
 
    sqlite3_close(db);
    return 0;
}

这段代码展示了如何在C/C++中使用SQLite3库进行基本的数据库操作，包括打开数据库、创建表、插入数据和查询数据。代码简洁，注释丰富，对于SQLite3数据库操作的初学者很有借鉴和借鉴的价值。

- 阅读更多 -
Tomcat 本地部署前后端分离项目
System
2024-09-03
所有,java

要在Tomcat本地部署前后端分离的项目，你需要将前端的静态资源放置在Tomcat的webapps目录下，并确保Tomcat配置能正确处理API请求。以下是步骤和示例配置：

  1. 将前端构建生成的静态文件（例如index.html, js, css, img等）复制到Tomcat的webapps目录下的一个新文件夹中，比如叫myapp。
  2. 确保Tomcat的web.xml配置文件正确配置了servlet和servlet-mapping，以便能正确处理API请求。
  3. 如果前端使用的是HTML5的History模式，你可能需要配置Tomcat的web.xml来重写所有前端路由到index.html。
  4. 如果前端应用需要通过API代理访问其他服务，你可能需要配置Tomcat作为代理服务器，使用nginx或Apache作为反向代理。

以下是一个简单的web.xml配置示例，它重写所有路径到index.html，并为API路径指定一个特定的servlet处理：




<web-app ...>
 
  <!-- 配置前端静态资源的servlet -->
  <servlet>
    <servlet-name>static-content</servlet-name>
    <servlet-class>org.apache.catalina.servlets.DefaultServlet</servlet-class>
    <init-param>
      <param-name>debug</param-name>
      <param-value>0</param-value>
    </init-param>
    <init-param>
      <param-name>listings</param-name>
      <param-value>false</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>
 
  <servlet-mapping>
    <servlet-name>static-content</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
 
  <!-- 配置API路径的servlet，这个需要根据你的后端框架进行相应配置 -->
  <servlet>
    <servlet-name>api</servlet-name>
    <servlet-class>你的API处理类</servlet-class>
  </servlet>
 
  <servlet-mapping>
    <servlet-name>api</servlet-name>
    <url-pattern>/api/*</url-pattern>
  </servlet-mapping>
 
</web-app>

确保替换<servlet-class>为你的API处理类。

以上是部署前后端分离项目的基本步骤和配置示例。具体细节可能因项目的实际情况而有所不同，比如前端路由的处理、API的代理设置等。

- 阅读更多 -
Copyright © 2026 Tech Blog
All Right Reserved | 京ICP备19053165号