分类后端技术下的文章

2024-09-03

在Spring Cloud中，Ribbon是一个基于HTTP和TCP的客户端负载均衡工具，它可以在客户端配置服务提供者地址后，在服务消费者调用服务提供者时，通过一定的负载均衡算法，选择一个服务提供者进行调用。

以下是一个使用Ribbon作为客户端负载均衡器的示例代码：

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




<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
</dependency>

配置服务提供者地址列表：




my-service:
  ribbon:
    listOfServers: "localhost:8080,localhost:8081"

使用RestTemplate调用服务时，Ribbon会自动应用负载均衡策略：




@Autowired
private RestTemplate restTemplate;
 
@RibbonClient(name = "my-service")
public class MyService {
 
    @Bean
    public RestTemplate restTemplate(RestTemplateBuilder builder) {
        return builder.build();
    }
 
    public String callService() {
        return restTemplate.getForObject("http://my-service/api/service", String.class);
    }
}

在上述代码中，我们首先通过Maven添加了Ribbon的依赖。然后在配置文件中指定了服务提供者的地址列表。在服务消费者中，我们使用了@RibbonClient注解来指定使用Ribbon进行负载均衡的服务名称，并通过RestTemplate调用服务时，Ribbon会根据配置的负载均衡策略选择一个服务提供者进行访问。

- 阅读更多 -

java Redission 分布式锁的使用

System

2024-09-03

所有,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 tryLock() {
        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);
        }
    }
}

这个简化版本的RedisDistributedLock类提供了tryLock和unlock方法，用于尝试获取和释放分布式锁。这个实现假设Redis服务器运行正常且可以连接。在实际应用中，你需要处理Jedis实例的创建和关闭，异常处理，以及合理设置锁的超时时间等问题。

- 阅读更多 -

SpringBoot升级到2.7.18后不兼容的地方

System

2024-09-03

所有,java

Spring Boot 2.7.18 的发布可能会导致与之前版本的不兼容。这里列出一些常见的不兼容点，并提供简要的解决方法：

JPA 配置更改:
Spring Boot 2.7 可能更改了 JPA 配置的默认行为。如果你在 application.properties 或 application.yml 中指定了 JPA 配置，你可能需要更新这些配置以匹配新的默认值。
解决方法: 根据官方文档调整配置。
Actuator 端点更改:
Spring Boot 2.7 可能更改了 Actuator 端点的路径或默认禁用了一些端点。
解决方法: 根据官方文档调整配置，确保所需的端点保持启用状态。
日志配置更改:
Spring Boot 2.7 可能更改了日志配置的默认行为。
解决方法: 根据官方文档检查并更新日志配置。
Jetty 和 Tomcat 更新:
Spring Boot 2.7 可能引入了对 Jetty 和 Tomcat 服务器的更新，可能需要更新依赖或调整服务器配置。
解决方法: 根据官方文档更新依赖，调整服务器设置。
Jackson 依赖更新:
Spring Boot 2.7 可能引入了 Jackson 的新版本，可能会影响你的序列化和反序列化。
解决方法: 检查 Jackson 的 API 更改，更新代码以适应新的序列化/反序列化行为。
Spring Data 更改:
Spring Data 可能有不兼容的更新。
解决方法: 根据 Spring Data 的更新文档调整代码。
测试不再支持的类和方法:
Spring Boot 2.7 可能不再支持一些过时的类和方法。编译器可能会报告警告或错误，提示你使用新的替代方法。
解决方法: 根据编译器的警告和错误信息，更新你的代码以使用新的方法和类。
Spring Security 更改:
Spring Security 可能有不兼容的更新。
解决方法: 根据 Spring Security 的更新文档调整代码。
@ConditionalOnClass 和 @ConditionalOnMissingClass 的行为更改:
Spring Boot 2.7 可能更改了这些注解的行为。
解决方法: 根据官方文档更新你的条件注解使用。
Java 版本要求:
Spring Boot 2.7 可能需要更高版本的 Java。
解决方法: 升级你的 Java 版本至所需的最低要求。

请确保在升级后全面测试你的应用，以确保所有功能都按预期工作。如果遇到具体问题，可以参考 Spring Boot 的官方文档或搜索特定的错误代码和消息来找到解决方案。

- 阅读更多 -

【Redis】Zset有序集合常用命令以及使用场景

System

2024-09-03

所有,redis

Redis的Zset（Sorted Set）是一个不允许有重复的成员，且每个成员都关联一个分数的有序集合。通过分数可以有序地进行访问。

常用的Zset命令包括：

ZADD key [NX|XX] [CH] [INCR] score member [score member ...]：添加成员及其分数到Zset。
ZCARD key：获取Zset中成员的数量。
ZCOUNT key min max：获取分数在指定范围内的成员的数量。
ZINCRBY key increment member：增加指定成员的分数。
ZRANGE key start stop [WITHSCORES]：按照索引范围返回成员。
ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]：按分数范围返回成员。
ZREM key member [member ...]：移除一个或多个成员。
ZSCORE key member：获取成员的分数。

使用场景：

排行榜：可以使用Zset按分数存储用户分数，并使用ZRANGE来获取排行榜上的用户。
时间轴行为：可以使用Zset按时间戳存储事件，并使用ZRANGEBYSCORE来获取一定时间范围内的事件。
优先队列：可以使用Zset按优先级存储任务，并使用ZRANGE来获取按优先级排序的任务。

示例代码（Python使用redis-py库）：




import redis
 
# 连接Redis
r = redis.Redis(host='localhost', port=6379, db=0)
 
# 添加成员
r.zadd('ranking', {'player1': 100, 'player2': 200})
 
# 获取成员数量
count = r.zcard('ranking')
print(f'Members count: {count}')
 
# 增加成员分数
r.zincrby('ranking', 10, 'player1')
 
# 获取排名前3的玩家
players = r.zrange('ranking', 0, 2)
print(f'Top 3 players: {players}')
 
# 获取分数在150到230之间的玩家数量
count_in_score = r.zcount('ranking', 150, 230)
print(f'Players with score between 150 and 230: {count_in_score}')

System

2024-09-03

所有,java

以下是一个简化的代码示例，展示了如何使用Apache POI和Spring Boot来导入Excel数据到MySQL数据库：




import org.apache.poi.ss.usermodel.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;
 
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
 
@Service
public class ExcelService {
 
    @Autowired
    private YourRepository yourRepository; // 替换为你的Repository接口
 
    public List<YourEntity> importExcel(MultipartFile file) {
        List<YourEntity> entities = new ArrayList<>();
        try (InputStream is = file.getInputStream(); Workbook workbook = WorkbookFactory.create(is)) {
            Sheet sheet = workbook.getSheetAt(0); // 获取第一个Sheet页
            for (Row row : sheet) {
                if (row.getRowNum() > 0) { // 跳过标题行
                    YourEntity entity = new YourEntity();
                    entity.setField1(row.getCell(0).getStringCellValue());
                    entity.setField2(row.getCell(1).getDateCellValue());
                    // ... 设置更多字段
                    entities.add(entity);
                }
            }
            yourRepository.saveAll(entities); // 保存到数据库
        } catch (Exception e) {
            e.printStackTrace();
        }
        return entities;
    }
}

在这个示例中，YourEntity应该替换为你的实体类，YourRepository应该替换为你的Spring Data JPA仓库接口。你需要根据你的实际数据模型调整字段的获取和设置。

注意：这个代码示例没有包含完整的异常处理和边界情况检查，它只是展示了核心的导入逻辑。在实际应用中，你需要添加必要的异常处理和安全检查来确保代码的稳健性和安全性。

- 阅读更多 -

springboot mybatis-plus数据库超时配置

System

2024-09-03

所有,java

在Spring Boot项目中使用MyBatis-Plus时，可以通过配置文件来设置数据库操作的超时时间。以下是如何配置数据库超时的示例：

在application.properties或application.yml中添加MySQL的超时配置：

如果你使用的是application.properties文件，添加如下配置：




# 设置数据库连接超时时间（单位为毫秒）
spring.datasource.hikari.data-source-properties.socketTimeout=30000
spring.datasource.hikari.data-source-properties.connectTimeout=10000

如果你使用的是application.yml文件，添加如下配置：




spring:
  datasource:
    hikari:
      data-source-properties:
        socketTimeout: 30000
        connectTimeout: 10000

这里的socketTimeout是数据库连接超时时间，即数据库服务器响应超时时间；connectTimeout是数据库连接的超时时间，即尝试连接数据库的超时时间。

如果你使用的是MyBatis-Plus的分页插件，还可以设置分页超时：

在application.properties或application.yml中添加MyBatis-Plus分页插件的超时配置：




# 设置MyBatis-Plus分页插件的超时时间（单位为毫秒）
mybatis-plus.global-config.db-config.page-size-zero=true
mybatis-plus.global-config.db-config.reasonable=true
mybatis-plus.global-config.db-config.page-size=10
mybatis-plus.global-config.db-config.max-limit=100

或者：




mybatis-plus:
  global-config:
    db-config:
      page-size-zero: true
      reasonable: true
      page-size: 10
      max-limit: 100

在这里，page-size-zero表示当pageSize=0时，是否返回所有结果，reasonable表示分页合理化，page-size表示分页默认每页显示记录数，max-limit表示分页最大页数。

以上配置可以根据实际需求进行调整。

- 阅读更多 -

Tomcat相关基础以及安装运行

System

2024-09-03

所有,java

Tomcat是一个开源的Java Servlet容器，用于运行Java Web应用程序。以下是安装和运行Tomcat的基本步骤：

下载Tomcat：访问Apache Tomcat官方网站（https://tomcat.apache.org/），下载对应操作系统的Tomcat版本。
安装Tomcat：
- Windows：解压下载的压缩包到指定目录。
- Linux：解压下载的压缩包到指定目录，可能需要给bin目录下的脚本文件执行权限。
配置环境变量：
- CATALINA_HOME：设置为Tomcat安装目录的路径。
- JAVA_HOME：设置为Java JDK安装目录的路径。
- 在PATH变量中添加%CATALINA_HOME%\bin（Windows）或$CATALINA_HOME/bin（Linux）。
运行Tomcat：
- Windows：在命令行中运行bin\startup.bat，关闭则运行bin\shutdown.bat。
- Linux：在终端中运行bin/startup.sh，关闭则运行bin/shutdown.sh。
检查Tomcat是否启动：打开浏览器，访问http://localhost:8080，如果看到Tomcat的欢迎页面，则表示Tomcat已成功运行。

以下是一个简单的Tomcat目录结构说明：




/bin - 包含启动和关闭Tomcat的脚本
/conf - 包含配置文件，如server.xml和web.xml
/lib - 包含Tomcat运行时需要的jar文件和其他库
/logs - 包含日志文件
/temp - 包含临时文件
/webapps - 包含部署的web应用
/work - 包含JSP编译后的servlet文件

安装和运行Tomcat的详细步骤可能会根据不同的操作系统和Tomcat版本略有差异，但基本概念相同。

System

2024-09-03

所有,AIGC

报错解释：

这个错误表明你尝试访问的 openai 模块中不存在 attribu 属性或方法。这通常是因为你尝试调用的属性名有拼写错误，或者该属性在你使用的 openai 库的版本中不存在。

解决方法：

检查属性名是否拼写正确。如果你在代码中看到 attribu，请确保它是你想要访问的正确属性名。
确认你安装的 openai 库版本是否支持你尝试使用的属性或方法。你可以通过升级库版本来解决这个问题，使用以下命令：
```
pip install --upgrade openai
```
如果你确定属性名和库版本都没有问题，那么可能是你的代码中导入模块的方式有误。确保你的导入语句是这样的：
```
import openai
```
或者，如果你只需要使用 openai 中的某个特定属性或方法，你可以这样导入：
```
from openai import Whisper
```
然后，确保你调用的属性或方法是对应模块/类的一部分。
如果以上步骤都不能解决问题，可以查看 openai 的官方文档或者GitHub仓库的Issues来寻找可能的解决方案或者报告这个错误。

- 阅读更多 -

Redis-Lock 使用指南

System

2024-09-03

所有,redis




import redis
import time
import uuid
 
class RedisLock(object):
    def __init__(self, client, lock_name, acquire_timeout=10, lock_timeout=10):
        self.client = client
        self.lock_name = lock_name
        self.acquire_timeout = acquire_timeout
        self.lock_timeout = lock_timeout
        self.uuid = str(uuid.uuid4())
        self.lock_key = 'lock:' + lock_name
        self.uuid_key = 'lock_uuid:' + lock_name
 
    def _acquire(self):
        end = time.time() + self.acquire_timeout
        while time.time() < end:
            self.client.set(self.lock_key, '1', ex=self.lock_timeout, nx=True)
            self.client.set(self.uuid_key, self.uuid)
            if self.client.get(self.lock_key) == '1' and self.uuid == self.client.get(self.uuid_key):
                return True
            time.sleep(0.001)
        return False
 
    def acquire(self):
        return self._acquire()
 
    def release(self):
        if self.client.get(self.lock_key) == '1' and self.uuid == self.client.get(self.uuid_key):
            self.client.delete(self.lock_key)
            self.client.delete(self.uuid_key)
            return True
        return False
 
# 使用示例
client = redis.StrictRedis(host='localhost', port=6379, db=0)
lock = RedisLock(client, 'my_lock')
 
if lock.acquire():
    try:
        # 这里放置需要互斥执行的代码
        print('Lock acquired. Exclusive access to the code block.')
    finally:
        # 确保释放锁
        if not lock.release():
            print('Unable to release the lock!')
else:
    print('Unable to acquire the lock.')

这段代码实现了一个基本的Redis分布式锁。它使用Redis的SET命令的NX（只在键不存在时设置）和PX（设置键的过期时间）选项来尝试获取锁。在释放锁时，它检查锁是否仍然属于请求者，然后删除键以释放锁。这个实现没有使用看门狗机制，因此在获取锁后，如果执行的时间超过了锁的超时时间，锁会自动失效，避免了死锁的发生。

- 阅读更多 -

【Redis官方解答】为啥Redis Cluster设计成16384个槽？

System

2024-09-03

所有,redis

Redis Cluster设计成16384个槽（slot）的原因是为了保证数据分布和扩展性。Redis Cluster通过分片机制将数据分散在不同的节点上。16384个槽可以保证足够的数据分布度，同时也足够的槽位数量以支持大规模的数据集合。

如果使用较少的槽，可能会导致数据分布不均或者不足以支持大规模数据。使用太多的槽可能会导致管理槽的开销过大，并且会增加数据迁移和重分配的复杂性。

因此，选择16384个槽是一个平衡的选择，既能满足大多数部署的需求，也能在数据量增长时提供足够的扩展能力。

- 阅读更多 -