分类后端技术下的文章

2024-08-29




import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;
 
@Configuration
public class RedisConfig {
 
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
 
        // 使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
 
        // 配置template的序列化方式
        template.setDefaultSerializer(jackson2JsonRedisSerializer);
 
        return template;
    }
 
    @Bean
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
 
        // 设置键的序列化方式
        template.setKeySerializer(new StringRedisSerializer());
        // 设置值的序列化方式
        template.setValueSerializer(new StringRedisSerializer());
 
        return template;
    }
}

这段代码定义了两个Bean，一个用于序列化Object的RedisTemplate和一个用于操作字符串的StringRedisTemplate。通过自定义Jackson2JsonRedisSerializer来实现对象的序列化与反序列化，以便于存储复杂类型的数据。同时，它展示了如何设置RedisTemplate的默认序列化方式和键值的特定序列化方式。这是一个在Spring Boot项目中整合Redis的实践案例。

- 阅读更多 -

VSCode配置之C++ & SQLite3极简配置方案

System

2024-08-29

所有,数据库




{
    "configurations": [
        {
            "name": "Linux",
            "includePath": [
                "${workspaceFolder}/**",
                "/usr/local/include/**",
                "/usr/include/sqlite3"
            ],
            "defines": [],
            "compilerPath": "/usr/bin/g++",
            "cStandard": "c11",
            "cppStandard": "c++17",
            "intelliSenseMode": "linux-gcc-x64"
        }
    ],
    "version": 4
}

这个配置适用于Linux系统，设置了includePath，包括了工作目录下的任何子目录，以及SQLite3的标准库目录。同时，设置了compilerPath为Linux系统下G++编译器的路径。这样配置后，VSCode的C++插件就可以提供智能感知和代码高亮等功能，同时也可以编译和运行C++代码，前提是你的系统已经安装了G++编译器和SQLite3库。

- 阅读更多 -

oracle补丁升级（19.3-19.22）

System

2024-08-29

所有,数据库

Oracle数据库补丁升级通常涉及以下步骤：

检查当前数据库版本。
确认需要升级到的目标版本。
下载对应的补丁安装包。
执行补丁安装。

以下是一个简化的示例，演示如何在Oracle数据库中应用补丁升级：




-- 1. 登录到Oracle数据库
sqlplus / as sysdba
 
-- 2. 检查当前数据库版本
SELECT * FROM v$version;
 
-- 3. 确认补丁文件（假设补丁文件名为p19301896_190000_Linux-x86-64.zip）
-- 下载补丁到服务器本地（此步骤通常在Oracle官网进行）
 
-- 4. 安装补丁
-- 解压补丁文件
unzip p19301896_190000_Linux-x86-64.zip
 
-- 进入解压后的补丁目录
cd 19301896/
 
-- 运行dbpatch命令应用补丁
opatch apply
 
-- 验证补丁安装是否成功
SELECT * FROM v$version;

请注意，实际的补丁安装步骤可能会根据补丁的具体情况有所不同，如需要在OPatch工具中注册补丁或者执行额外的前置步骤。始终建议在升级前备份数据库，并检查Oracle官方文档以获取最新的升级指导。

- 阅读更多 -

JavaWeb：web基本概论与使用Tomcat发布一个网站

System

2024-08-29

所有,java

在JavaWeb中，我们可以使用Servlet、JSP、JavaBean等技术来创建动态网站。以下是一个简单的例子，展示如何使用Tomcat服务器来发布一个简单的网站。

创建一个简单的Servlet：




import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
 
public class HelloWorldServlet extends HttpServlet {
    public void doGet(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
            response.setContentType("text/html");
            PrintWriter out = response.getWriter();
            out.println("<html><body><h1>Hello World</h1></body></html>");
    }
}

编译这个Servlet，确保你有servlet-api.jar在classpath中。




javac -cp servlet-api.jar HelloWorldServlet.java

打包这个Servlet到一个.war文件中（Web Application Archive）。




jar cvf HelloWorld.war HelloWorldServlet.class

把.war文件复制到Tomcat的webapps目录下。




cp HelloWorld.war /path/to/tomcat/webapps/

启动Tomcat服务器。




/path/to/tomcat/bin/startup.sh

访问你的网站：

打开浏览器，输入 http://localhost:8080/HelloWorld/, 你应该能看到 "Hello World" 的消息。

注意：确保Tomcat服务器已经安装并且在运行中。如果你更改了默认的端口号，请确保在访问时使用正确的端口号。

System

2024-08-29

所有,AIGC




import os
import gradio as gr
import numpy as np
from PIL import Image
import requests
 
# 加载模型和参数
model_checkpoint_path = "path_to_your_stable_diffusion_model_checkpoint.ckpt"
model_config_path = "path_to_your_stable_diffusion_model_config.json"
model_dir = os.path.dirname(model_checkpoint_path)
 
# 文本到图像的API调用
def text_to_image(prompt):
    response = requests.post(f"http://localhost:7860/generate_image", json={
        "prompt": prompt,
        "n_samples": 1,  # 生成1张图像
        "seed": None,
        "steps": 50,
        "model_name": model_config_path,
        "model_directory": model_dir,
        "run_in_background": False,
        "cuda_device": 0
    })
    image_path = response.json()["images"][0]
    return image_path
 
# 图像到图像的API调用
def image_to_image(inp_img):
    img_bytes = inp_img.read()
    image = Image.open(img_bytes)
    image_array = np.asarray(image)
    response = requests.post(f"http://localhost:7860/conditional_image_synthesis", json={
        "input_code": image_array.tolist(),
        "guidance_scale": 7.5,
        "seed": None,
        "steps": 100,
        "model_name": model_config_path,
        "model_directory": model_dir,
        "run_in_background": False,
        "cuda_device": 0
    })
    image_path = response.json()["images"][0]
    return image_path
 
# 初始化Gradio界面
gr.Interface(fn=text_to_image, inputs="text", outputs="image", title="Stable Diffusion Text to Image").launch()
gr.Interface(fn=image_to_image, inputs="image", outputs="image", title="Stable Diffusion Image to Image").launch()

在这个代码实例中，我们首先加载了Stable Diffusion模型的参数和配置。然后，我们定义了两个函数text_to_image和image_to_image，它们分别用于文本到图像和图像到图像的转换。这两个函数通过HTTP POST请求调用Stable Diffusion WebUI的后端API。最后，我们使用gradio库初始化了两个用户界面，让用户可以通过输入文本或上传图像来进行转换。

- 阅读更多 -

oracle使用rman备份实现异机数据恢复

System

2024-08-29

所有,数据库




-- 假设我们已经在Oracle数据库中配置好了RMAN环境，并且有一个有效的备份目录位置。
 
-- 首先，我们需要连接到RMAN并且确保目标数据库处于关闭状态。
RMAN target /
shutdown immediate;
 
-- 启动RMAN并且恢复控制文件
startup nomount;
restore controlfile from '/path/to/controlfile/backup';
 
-- 挂载数据库，打开数据库以便进行恢复操作
alter database mount;
 
-- 恢复数据文件，日志文件，和归档日志文件
-- 这里假设你有最新的数据文件，日志文件和归档日志文件的备份
restore database;
 
-- 恢复完成后，需要恢复的操作系统命令来恢复文件的权限和属性
-- 这通常涉及到使用 'chown' 和 'chmod' 命令
 
-- 恢复完成后，打开数据库供用户使用
alter database open resetlogs;
 
-- 确认数据库已经成功恢复
select open_mode from v$database;

在实际操作中，你需要根据你的RMAN备份策略和具体的数据库环境来调整这些命令。这个例子提供了一个基本的框架，展示了如何使用RMAN将Oracle数据库恢复到异机环境中。

System

2024-08-29

所有,python

要在Python中读取Excel内容并存入字典，可以使用pandas库。要将字典内容写入Excel文件，同样可以使用pandas。

首先安装pandas和openpyxl（用于处理Excel文件）：




pip install pandas openpyxl

以下是读取Excel内容并存入字典以及将字典内容写入Excel文件的示例代码：




import pandas as pd
 
# 读取Excel内容并存入字典
def read_excel_to_dict(file_path):
    df = pd.read_excel(file_path)
    return df.to_dict()
 
# 将字典内容写入Excel文件
def write_dict_to_excel(data_dict, file_path):
    df = pd.DataFrame(data_dict)
    df.to_excel(file_path, index=False)
 
# 示例使用
# 读取Excel
excel_file_path = 'example.xlsx'
data_dict = read_excel_to_dict(excel_file_path)
print(data_dict)
 
# 写入Excel
output_file_path = 'output.xlsx'
write_dict_to_excel(data_dict, output_file_path)

请确保example.xlsx和output.xlsx文件路径正确，且当前路径有写入权限。以上代码假设Excel文件中的数据可以直接转换为字典，每个列名映射到一个键，每行映射到一个值列表。如果Excel文件格式更复杂，可能需要进一步处理数据。

- 阅读更多 -

【SpringBoot篇】基于Redis分布式锁的误删问题和原子性问题

System

2024-08-29

所有,java

关于Redis分布式锁的误删问题，可以通过设置锁的过期时间和使用唯一的客户端标识来解决。

设置锁的过期时间：当获取锁时，设置一个合理的过期时间，以防止服务器宕机或者其他意外情况导致锁未能释放。
唯一客户端标识：为每个客户端生成一个唯一的标识，比如UUID，用于标识锁的拥有者。在释放锁时，只有拥有该标识的客户端才能释放锁。

原子性问题可以通过使用Lua脚本来保证。Lua脚本在Redis中是原子性的，可以确保包含在脚本中的多个命令一次性执行，不会被其他操作打断。

以下是一个简单的Lua脚本示例，用于解决原子性问题和误删问题：




-- 获取锁的Lua脚本
local lock_key = KEYS[1]
local lock_value = ARGV[1]
local expire_time = ARGV[2]
 
-- 尝试获取锁
if (redis.call('exists', lock_key) == 0) then
    -- 锁不存在，设置锁并设置过期时间
    redis.call('hset', lock_key, lock_value, 1)
    redis.call('expire', lock_key, expire_time)
    return true
elseif (redis.call('hexists', lock_key, lock_value) == 1) then
    -- 已经拥有锁，可以重入
    redis.call('hincrby', lock_key, lock_value, 1)
    return true
else
    -- 其他客户端拥有锁
    return false
end
 
-- 释放锁的Lua脚本
local lock_key = KEYS[1]
local lock_value = ARGV[1]
 
-- 检查是否是锁的拥有者
local counter = redis.call('hget', lock_key, lock_value)
if (counter and counter > 0) then
    -- 减少锁的计数
    counter = redis.call('hincrby', lock_key, lock_value, -1)
    if (counter == 0) then
        -- 释放锁
        redis.call('del', lock_key)
    end
    return true
else
    -- 非法释放锁
    r

System

2024-08-29

所有,redis

Redis 的 Sorted Set（有序集合）是一种数据类型，它不仅存储元素，而且还将每个元素关联到一个浮点数的分数。在 Sorted Set 中，元素是唯一的，但分数可以重复。Sorted Set 中的元素按分数进行排序，分数可以升序或降序排序。

一、命令语法：

ZADD key [NX|XX] [CH] [INCR] score member [score member ...]：将一个或多个成员元素及其分数值加入到有序集当中。
ZCARD key：获取有序集的成员数。
ZCOUNT key min max：计算在有序集中分数在 min 和 max 之间的成员的数量。
ZINCRBY key increment member：有序集成员的分数加上增量 increment。
ZRANGE key start stop [WITHSCORES]：通过索引区间返回有序集成员。
ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]：根据分数返回有序集成员的列表。
ZRANK key member：返回有序集成员的排名。
ZREM key member [member ...]：移除有序集中的一个或多个成员。
ZREVRANGE key start stop [WITHSCORES]：有序集成员按分数从高到低排列。
ZREVRANGEBYSCORE key max min [WITHSCORES] [LIMIT offset count]：有序集成员按分数从高到低排列。
ZREVRANK key member：返回有序集成员的排名，成员按分数从高到低排列。
ZSCORE key member：获取有序集中成员的分数。
ZUNIONSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [SUM|MIN|MAX]：计算给定的一个或多个有序集的并集，并存储在新的有序集合 key 中。
ZINTERSTORE destination numkeys key [key ...] [WEIGHTS weight [weight ...]] [SUM|MIN|MAX]：计算给定的一个或多个有序集的交集，并存储在新的有序集合 key 中。

二、操作示例：

添加成员到 Sorted Set：




ZADD myzset 1 "one"
ZADD myzset 2 "two" 3 "three"

获取 Sorted Set 的成员数：




ZCARD myzset

获取 Sorted Set 指定分数范围内的成员：




ZRANGEBYSCORE myzset 1 3

获取 Sorted Set 的成员分数：




ZSCORE myzset "two"

移除 Sorted Set 的成员：




ZREM myzset "one"

三、命令返回值：

ZADD：返回被成功添加的新成员的数量，不包括那些被更新的、已经存在的成员的分数。
ZCARD：返回有序集的成员数。
ZCOUNT：返回分数在 min 和 max 之间的成员的数量。
ZINCRBY：返回新的成员分数值。
ZRANGE 和 ZRANGEBYSCORE：返回指定范围内的成员列表。
ZRANK 和

- 阅读更多 -

SpringBoot整合ShardingJDBC按时间分表及自动建表

System

2024-08-29

所有,java




@Configuration
public class ShardingJdbcConfig {
 
    @Bean
    public DataSource dataSource() {
        // 配置数据源
        ShardingDataSource dataSource = ShardingDataSourceFactory.createDataSource(
            createDataSourceMap(), 
            createShardingRule(), 
            new Properties()
        );
        return dataSource;
    }
 
    private Map<String, DataSource> createDataSourceMap() {
        // 创建数据源映射
        Map<String, DataSource> result = new HashMap<>();
        result.put("ds_0", createDataSource("ds_0"));
        // 可以添加更多数据源
        return result;
    }
 
    private DataSource createDataSource(String dataSourceName) {
        // 创建真实的数据源，例如HikariCP
        HikariDataSource dataSource = new HikariDataSource();
        // 设置数据源属性，例如URL、用户名、密码等
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/" + dataSourceName);
        // ...其他配置
        return dataSource;
    }
 
    private ShardingRule createShardingRule() {
        // 配置分表规则
        TableRuleConfiguration tableRuleConfig = new TableRuleConfiguration("t_order", "ds_0.t_order_${date_day}");
        tableRuleConfig.setDatabaseShardingStrategyConfig(new InlineShardingStrategyConfiguration("order_id", "ds_${order_id % 2}"));
        tableRuleConfig.setTableShardingStrategyConfig(new InlineShardingStrategyConfiguration("order_id", "t_order_${date_day}"));
 
        // 创建分库分表规则
        ShardingRuleConfiguration shardingRuleConfig = new ShardingRuleConfiguration();
        shardingRuleConfig.getTableRuleConfigs().add(tableRuleConfig);
        // 可以添加更多的分表配置
 
        // 添加分库策略
        shardingRuleConfig.getBindingTableGroups().add("t_order,t_order_item");
 
        // 添加时间范围策略
        shardingRuleConfig.getAllTables().get("t_order_${date_day}").setActualDataNodes("ds_${0..1}.t_order_${date_day}");
 
        // 自动创建表配置
        Properties properties = new Properties();
        properties.setProperty("sql.show", "true");
        // ...其他配置
 
        // 返回ShardingRule实例
        return new ShardingRule(shardingRuleConfig, createDataSourceMap().values(), properties);
    }
}

这个配置类展示了如何在SpringBoot应用中配置ShardingJDBC来实现按照时间和用户ID进行分表，并且如何配置数据源和自动创建表。这个例子中使用了ShardingJdbcFactory来创建ShardingDataSource，并且展示了如何配置分

- 阅读更多 -