分类后端技术下的文章

2024-09-06




#include "chat.h"
 
// 其他函数实现略...
 
// 初始化数据库
int init_db(sqlite3 **db) {
    int ret = sqlite3_open("chat.db", db);
    if (ret != SQLITE_OK) {
        fprintf(stderr, "无法打开数据库: %s\n", sqlite3_errmsg(*db));
        sqlite3_close(*db);
        return -1;
    }
 
    char *errmsg = NULL;
    const char *create_table_sql = "CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, username TEXT UNIQUE NOT NULL, password TEXT NOT NULL);";
    ret = sqlite3_exec(*db, create_table_sql, NULL, NULL, &errmsg);
    if (ret != SQLITE_OK) {
        fprintf(stderr, "创建表失败: %s\n", errmsg);
        sqlite3_free(errmsg);
        sqlite3_close(*db);
        return -1;
    }
 
    return 0;
}
 
// 关闭数据库
void close_db(sqlite3 *db) {
    sqlite3_close(db);
}
 
// 添加用户到数据库
int add_user_to_db(sqlite3 *db, const char *username, const char *password) {
    char *errmsg = NULL;
    char sql[SQL_BUF_LEN];
    snprintf(sql, SQL_BUF_LEN, "INSERT INTO users (username, password) VALUES ('%s', '%s');", username, password);
    int ret = sqlite3_exec(db, sql, NULL, NULL, &errmsg);
    if (ret != SQLITE_OK) {
        fprintf(stderr, "添加用户失败: %s\n", errmsg);
        sqlite3_free(errmsg);
        return -1;
    }
 
    return 0;
}
 
// 用户登录验证
int login_user(sqlite3 *db, const char *username, const char *password) {
    char *errmsg = NULL;
    char sql[SQL_BUF_LEN];
    snprintf(sql, SQL_BUF_LEN, "SELECT * FROM users WHERE username='%s' AND password='%s';", username, password);
    sqlite3_stmt *stmt;
    int ret = sqlite3_prepare_v2(db, sql, -1, &stmt, NULL);
    if (ret != SQLITE_OK) {
        fprintf(stderr, "查询失败: %s\n", errmsg);
        sqlite3_free(errmsg);
        return -1;
    }
 
    ret = sqlite3_step(stmt);
    if (ret == SQLITE_ROW) {
        sqlite3_finalize(stmt);
        return 0;
    } else if (ret == SQLITE_DONE) {
        fprintf(stderr, "用户名或密码错误\n");
        sqlite3_finalize(stmt);
        return -1;
    } else {
        fprintf(

- 阅读更多 -

Java 实现基于Redis的分布式锁

System

2024-09-06

所有,redis

以下是一个使用Jedis库实现基于Redis的分布式锁的简单示例：




import redis.clients.jedis.Jedis;
 
public class RedisDistributedLock {
 
    private Jedis jedis;
    private String lockKey; // 锁的键值
    private int expireTime; // 锁的超时时间
 
    public RedisDistributedLock(Jedis jedis, String lockKey, int expireTime) {
        this.jedis = jedis;
        this.lockKey = lockKey;
        this.expireTime = expireTime;
    }
 
    public boolean lock() {
        long expires = System.currentTimeMillis() + expireTime + 1;
        String expiresStr = String.valueOf(expires); // 锁到期时间
 
        if (jedis.setnx(lockKey, expiresStr) == 1) {
            // 获取锁成功
            jedis.expire(lockKey, expireTime); // 设置锁的过期时间
            return true;
        }
 
        String currentValueStr = jedis.get(lockKey); // Redis里面的时间
        if (currentValueStr != null && Long.parseLong(currentValueStr) < System.currentTimeMillis()) {
            String oldValueStr = jedis.getSet(lockKey, expiresStr);
            if (oldValueStr != null && oldValueStr.equals(currentValueStr)) {
                // 锁已过期，获取锁成功
                jedis.expire(lockKey, expireTime); // 设置锁的过期时间
                return true;
            }
        }
        return false; // 获取锁失败
    }
 
    public void unlock() {
        // 确保是该线程获得的锁才能被释放
        String currentValueStr = jedis.get(lockKey);
        if (currentValueStr != null && Long.parseLong(currentValueStr) > System.currentTimeMillis()) {
            jedis.del(lockKey); // 删除锁
        }
    }
}

使用方法：




Jedis jedis = new Jedis("localhost", 6379);
RedisDistributedLock lock = new RedisDistributedLock(jedis, "my_lock", 1000);
 
try {
    if (lock.lock()) {
        // 业务逻辑
    } else {
        // 获取锁失败，执行其他逻辑或者等待重试
    }
} finally {
    lock.unlock(); // 释放锁
}

这个示例中的lock方法尝试获取锁，如果获取成功，则设置锁的过期时间；如果获取失败，则检查锁是否已过期，如果已过期，则尝试重新获取锁。unlock方法则确保只有获得锁的线程才能释放锁，防止释放其他线程持有的锁。

- 阅读更多 -

springboo 整合 redis

System

2024-09-06

所有,redis

Spring Boot整合Redis可以通过Spring Data Redis或者Jedis两种方式实现。

使用Spring Data Redis

首先，添加依赖到你的pom.xml文件：




<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

然后，在application.properties或application.yml中配置Redis连接：




# application.properties
spring.redis.host=localhost
spring.redis.port=6379

接下来，你可以使用RedisTemplate或StringRedisTemplate来操作Redis：




import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.*;
 
@RestController
public class RedisController {
 
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
 
    @GetMapping("/set")
    public String setKey(@RequestParam String key, @RequestParam Object value) {
        redisTemplate.opsForValue().set(key, value);
        return "success";
    }
 
    @GetMapping("/get")
    public Object getKey(@RequestParam String key) {
        return redisTemplate.opsForValue().get(key);
    }
}

使用Jedis

添加依赖：




<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
</dependency>

配置Redis连接信息：




# application.properties
redis.host=localhost
redis.port=6379

使用Jedis操作Redis：




import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;
import redis.clients.jedis.Jedis;
 
@RestController
public class RedisController {
 
    @Value("${redis.host}")
    private String host;
 
    @Value("${redis.port}")
    private int port;
 
    @GetMapping("/set")
    public String setKey(@RequestParam String key, @RequestParam String value) {
        try (Jedis jedis = new Jedis(host, port)) {
            jedis.set(key, value);
        }
        return "success";
    }
 
    @GetMapping("/get")
    public String getKey(@RequestParam String key) {
        try (Jedis jedis = new Jedis(host, port)) {
            return jedis.get(key);
        }
    }
}

以上两种方式都可以实现Spring Boot整合Redis，你可以根据项目需求选择合适的方式。

- 阅读更多 -

SpringCloud 集成 RocketMQ 示例及配置详解

System

2024-09-06

所有,java




import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
public class ProducerController {
 
    @Autowired
    private RocketMQTemplate rocketMQTemplate;
 
    @GetMapping("/sendMessage")
    public String sendMessage(@RequestParam String message) {
        rocketMQTemplate.convertAndSend("topicTest:tagTest", message);
        return "消息发送成功";
    }
}

这段代码展示了如何在Spring Cloud项目中使用RocketMQTemplate发送消息。通过@Autowired注入RocketMQTemplate后，可以调用convertAndSend方法发送消息到指定的主题和标签。这里的topicTest:tagTest表示消息将发送到名为topicTest的主题，并带有标签tagTest。消息内容通过HTTP请求的message参数传递。

System

2024-09-06

所有,java




import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
 
@ControllerAdvice
public class GlobalExceptionHandler {
 
    // 处理所有Exception类型的异常
    @ExceptionHandler(Exception.class)
    public ResponseEntity<String> handleException(Exception e) {
        // 打印异常信息到日志
        // 可以在这里记录日志，发送错误通知等
        System.err.println("异常信息：" + e.getMessage());
 
        // 返回500内部服务器错误状态码和异常信息
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(e.getMessage());
    }
 
    // 可以添加更多的异常处理方法，针对不同的异常类型进行处理
}

这个代码示例展示了如何在Spring Boot应用中创建一个全局异常处理器。当应用中发生未被特定控制器处理的异常时，这个处理器会捕获并返回一个包含异常信息的HTTP 500响应。这是一个简单的例子，实际应用中可能需要更详细的异常处理逻辑。

System

2024-09-06

所有,java

在Spring Boot应用中整合Nacos作为配置中心，可以使用spring-cloud-starter-alibaba-nacos-config依赖。以下是整合和使用Nacos管理Spring Boot配置文件的步骤：

在pom.xml中添加依赖：




<dependencies>
    <!-- Spring Cloud Alibaba Nacos Config -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
    </dependency>
</dependencies>

在bootstrap.properties或bootstrap.yml中配置Nacos服务器地址和应用名：




# Nacos Config
spring.cloud.nacos.config.server-addr=127.0.0.1:8848
spring.application.name=my-springboot-application

在application.properties或application.yml中使用Nacos配置管理的配置：




# 配置一个示例配置项
my.custom.property: ${my.custom.property:defaultValue}

在Java代码中注入配置：




import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
public class ConfigController {
 
    @Value("${my.custom.property}")
    private String myCustomProperty;
 
    @GetMapping("/config")
    public String getConfig() {
        return myCustomProperty;
    }
}

将应用配置推送到Nacos：

可以使用Nacos的控制台或nacos-config工具将配置文件推送到Nacos。

以下是使用nacos-config工具的示例命令，将配置文件data.properties推送到Nacos：




sh nacos-config.sh -h 127.0.0.1 -p 8848 -g DEFAULT_GROUP -t my-springboot-application.properties -s data.properties

确保nacos-config.sh脚本在你的环境中是可用的，并且已经正确设置了Nacos服务器地址和认证信息。

注意：nacos-config.sh脚本是Nacos官方提供的一个工具，用于将配置文件推送到Nacos。这个脚本可能需要你从Nacos的GitHub仓库或者官网下载。解压Nacos压缩包后，通常可以在bin目录下找到这个脚本。

以上步骤完成后，当启动Spring Boot应用时，它会从Nacos配置中心加载配置。同时，你可以在Nacos控制台上管理这些配置，并在不重启应用的情况下，实时更新配置。

- 阅读更多 -

SpringBoot项目测试类@Test注解无法使用

System

2024-09-06

所有,java

如果您在SpringBoot项目中遇到测试类中@Test注解无法使用的问题，可能是以下原因导致的：

缺少依赖：确保您的项目中已经添加了JUnit依赖。如果使用Maven，可以在pom.xml中添加如下依赖：




<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>5.x.x</version>
    <scope>test</scope>
</dependency>

如果使用Gradle，在build.gradle中添加：




dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter:5.x.x'
}

导入错误的包：确保导入的是JUnit 5的org.junit.jupiter.api.Test而不是JUnit 4的org.junit.Test。
IDE配置问题：如果您正在使用IDE（如IntelliJ IDEA或Eclipse），确保已经配置了JUnit 5作为测试框架。
注解处理器缺失：如果使用的是注解驱动的测试（如Spring Test），确保添加了Spring Boot的测试模块依赖：




<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <version>2.x.x</version>
    <scope>test</scope>
</dependency>

这个模块会提供Spring Test与JUnit的集成。

如果以上都不是问题，请提供更具体的错误信息，以便进一步诊断。

- 阅读更多 -

springboot项目上高并发解决示例

System

2024-09-06

所有,java




import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.beans.factory.annotation.Autowired;
import com.example.service.TokenService;
 
@RestController
public class TokenController {
 
    @Autowired
    private TokenService tokenService;
 
    // 接口A，获取token
    @GetMapping("/getToken")
    public String getToken() {
        return tokenService.getToken();
    }
 
    // 接口B，验证token
    @GetMapping("/verifyToken")
    public boolean verifyToken(String token) {
        return tokenService.verifyToken(token);
    }
}

在这个简化的代码示例中，我们定义了两个接口getToken和verifyToken，分别用于获取和验证Token。这里的Token可以是用户登录后获得的访问令牌，用于身份验证和授权。在实际应用中，Token的生成和验证会更加复杂，可能涉及到分布式存储、缓存机制、安全加密等技术。

System

2024-09-06

所有,java

报错解释：

这个错误表明Tomcat服务器配置为监听10000端口，但是启动失败了。可能的原因包括：

端口10000已经被其他应用程序占用。
Tomcat没有权限监听该端口。
Tomcat配置文件中的端口配置错误。

解决方法：

检查端口10000是否被占用：
- 在Linux中，可以使用lsof -i:10000或netstat -tulnp | grep 10000。
- 在Windows中，可以使用netstat -ano | findstr :10000。
如果端口被占用，需要更改Tomcat配置文件中的端口号，选择一个未被占用的端口。
确保Tomcat有权限监听该端口：
- 如果是Linux系统，低于1024的端口可能需要root权限。可以使用sudo运行Tomcat或者将监听端口更改为1024以上的非特权端口。
检查Tomcat配置文件：
- 通常在Tomcat的conf/server.xml文件中配置。确保<Connector port="10000" ... />中的端口号没有错误，并且符合要求。
如果更改端口后问题依旧，重启Tomcat并观察是否有其他错误信息。

确保在进行更改后重启Tomcat以应用更改。

- 阅读更多 -

深入理解Spring Boot中的Profile配置

System

2024-09-06

所有,java

Spring Boot允许您为不同的环境或配置文件定义特定的属性集合，这些被称为“profiles”。通过使用profiles，您可以为不同的环境创建不同的配置文件，然后在启动应用程序时激活特定的profile。

以下是如何在Spring Boot中使用profiles的简单示例：

在application.properties或application.yml中定义通用配置。




# application.properties
app.message=Welcome to Spring Boot!

为不同的profile定义特定的配置文件。例如，为dev和prod profile。




# application-dev.properties
app.message=Welcome to Spring Boot in Development Environment!




# application-prod.yml
app:
  message: Welcome to Spring Boot in Production Environment!

在application.properties或application.yml中指定默认激活的profile。




# 激活dev profile
spring.profiles.active=dev

或者，在启动Spring Boot应用程序时通过命令行参数来指定激活的profile：




java -jar yourapp.jar --spring.profiles.active=prod

或者在IDE中设置程序参数：




--spring.profiles.active=prod

在代码中使用@Profile注解来根据当前激活的profile来条件地创建bean。




@Configuration
public class AppConfig {
 
    @Bean
    @Profile("dev")
    public DataSource devDataSource() {
        // 开发环境配置
        return new DevDataSource();
    }
 
    @Bean
    @Profile("prod")
    public DataSource prodDataSource() {
        // 生产环境配置
        return new ProdDataSource();
    }
}

通过这种方式，您可以管理多个环境的配置，而不需要在代码中硬编码环境特定的值。这有助于简化部署流程并提高应用程序的灵活性。

- 阅读更多 -