分类后端技术下的文章

【Spring】SpringBoot整合ShardingSphere并实现多线程分批插入10000条数据（进行分库分表操作）。

2024-09-04




import org.apache.shardingsphere.infra.config.properties.ConfigurationProperties;
import org.apache.shardingsphere.infra.context.metadata.MetaDataContexts;
import org.apache.shardingsphere.infra.context.runtime.RuntimeContext;
import org.apache.shardingsphere.infra.database.DefaultSchema;
import org.apache.shardingsphere.infra.executor.kernel.ExecutorEngine;
import org.apache.shardingsphere.infra.metadata.model.ShardingSphereMetaData;
import org.apache.shardingsphere.infra.optimize.context.OptimizerContext;
import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
import org.apache.shardingsphere.mode.manager.ContextManager;
import org.apache.shardingsphere.mode.metadata.MetaDataContextsBuilder;
import org.apache.shardingsphere.transaction.context.TransactionContexts;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
 
@Service
public class ShardingSphereService {
 
    @Resource
    private DataSource dataSource;
 
    public void insertMultiThread(int threadCount, int batchSize, final String sql) {
        // 构建ShardingSphere相关上下文
        Map<String, ShardingSphereMetaData> metaDataMap = new HashMap<>();
        metaDataMap.put("ds_0", new ShardingSphereMetaData("ds_0", dataSource.getSchema(), dataSource.getSchema().getConfig()));
        MetaDataContexts metaDataContexts = new MetaDataContextsBuilder(
                Collections.singletonMap("sharding_db", metaDataMap),
                Collections.emptyMap(),
                new ConfigurationProperties(new Properties()),
                dataSource.getShardingRule()).build();
 
        // 构建执行引擎
        ExecutorEngine executorEngine = new ExecutorEngine(metaDataContexts.getMetaData(DefaultSchema.LOGIC_NAME).getResource().getExecutorEngine());
 
        // 构建事务上下文
        TransactionContexts transactionContexts = new TransactionContexts(metaDataContexts.getMetaDataMap(), new TransactionContextsBuilder(metaDataContexts, executorEngine).build());
 
        // 构建运行时上下文
        RuntimeContext runtimeContext = new RuntimeContext(metaDataContexts, transactionContexts, executorEngine,

- 阅读更多 -

❓关于Oracle一键安装脚本的 21 个疑问与解答

System

2024-09-04

所有,数据库

由于提出的是关于Oracle一键安装脚本的21个疑问，我们将针对每个疑问提供解释和示例解答。

如何创建一键安装Oracle的脚本？

解释：创建一键安装Oracle的脚本通常涉及编写Shell脚本，其中包括下载Oracle软件包、设置环境变量、配置网络和启动Oracle实例等步骤。

示例：




#!/bin/bash
# 示例脚本的核心函数
 
# 下载Oracle软件包
wget http://example.com/oracle-software.zip
 
# 解压软件包
unzip oracle-software.zip
 
# 设置环境变量
export ORACLE_HOME=/u01/app/oracle/product/12.1.0/dbhome_1
export PATH=$PATH:$ORACLE_HOME/bin
 
# 配置Oracle实例
$ORACLE_HOME/bin/dbca -silent -createDatabase ...
 
# 启动Oracle实例
$ORACLE_HOME/bin/dbstart $ORACLE_HOME

如何处理不同操作系统的差异？

解释：在编写一键安装脚本时，需要使用条件语句来处理不同操发行版的差异。

示例：




#!/bin/bash
 
# 检测操作系统并安装相应的依赖包
if [ "$(uname)" = "Darwin" ]; then
    brew install oracle-client
else
    apt-get install oracle-client
fi

如何处理安装过程中的用户输入？

解释：可以使用here文档或者函数来封装用户输入逻辑。

示例：




#!/bin/bash
 
# 定义一个函数来获取用户输入
function get_input() {
    echo "请输入数据库的全局数据库名："
    read -r db_name
    echo "请输入数据库的系统标识符："
    read -r system_id
}
 
# 调用函数获取输入
get_input

如何处理安装失败的情况？

解释：在脚本中使用错误处理和日志记录来捕获和处理安装失败的情况。

示例：




#!/bin/bash
 
# 安装软件包
yum install oracle-database-server-12cR1-preinstall
 
# 检查安装是否成功
if [ $? -ne 0 ]; then
    echo "安装失败，退出脚本"
    exit 1
fi

如何处理Oracle软件的版本更新？

解释：使用变量来存储版本信息，并在脚本中引用这些变量。

示例：




#!/bin/bash
 
# 定义Oracle软件版本变量
oracle_version="12.1.0.2"
 
# 下载并安装Oracle软件
wget http://example.com/oracle-${oracle_version}.rpm
rpm -ivh oracle-${oracle_version}.rpm

如何处理Oracle数据库的自动启动配置？

解释：在脚本中使用系统管理工具来配置自动启动。

示例：




#!/bin/bash
 
# 配置Oracle实例自动启动
systemctl enable oracle-xe

如何处理Oracle数据库的初始化参数？

解释：在脚本中直接指定初始化参数。

示例：




#!/bin/bash
 
# 初始化参数示例
db_name="ORCL"
memory_target="

- 阅读更多 -

Laravel 中间件：中间件组 Draft

System

2024-09-04

所有,php

在 Laravel 中，中间件组是一种将多个中间件组合在一起的方式，这样可以方便地将它们应用到路由或路由组中。

要创建一个中间件组，你可以使用 middleware 方法在路由或路由组中指定它们。

首先，定义中间件组:




Route::middlewareGroup('throttle', [
    'throttle:60,1',
    'prefix:v1'
]);

然后，使用中间件组:




Route::group(['middleware' => 'throttle'], function () {
    // 这里是路由
});

这样，包含在 throttle 中间件组中的所有中间件都会按顺序应用到这个路由组中的所有路由上。

- 阅读更多 -

PostgreSQL实战-shell脚本备份数据库

System

2024-09-04

所有,数据库




#!/bin/bash
 
# 配置变量
DB_NAME="your_db_name"
DB_USER="your_db_user"
DB_PASS="your_db_password"
BACKUP_DIR="/path/to/your/backup/directory"
DATE=$(date +"%Y%m%d%H%M")
 
# 创建备份文件的tarball
tarball="${BACKUP_DIR}/${DB_NAME}_${DATE}.tar.gz"
pg_dump -U ${DB_USER} -W ${DB_PASS} ${DB_NAME} | gzip > ${tarball}
 
# 输出备份信息
echo "备份成功: ${tarball}"

这段代码使用了pg_dump命令来备份PostgreSQL数据库，并使用gzip进行压缩。脚本会在指定的目录中创建一个以时间戳命名的tarball文件。这是一个简洁的脚本，适合作为数据库备份的基础模板。

- 阅读更多 -

如何快速使用C语言操作sqlite3

System

2024-09-04

所有,数据库

要在C语言中快速操作SQLite3，你需要先安装SQLite3库。以下是一个简单的例子，展示了如何在C语言中使用SQLite3：

打开数据库连接。
执行SQL语句。
关闭数据库连接。




#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, "Can't open database: %s\n", sqlite3_errmsg(db));
        sqlite3_close(db);
        return 1;
    }
 
    // 创建一个表
    char *sql = "CREATE TABLE IF NOT EXISTS people (" \
                "id INTEGER PRIMARY KEY," \
                "name TEXT," \
                "age INTEGER," \
                "address TEXT" \
                ");";
 
    rc = sqlite3_exec(db, sql, callback, 0, &zErrMsg);
    if (rc != SQLITE_OK) {
        fprintf(stderr, "SQL error: %s\n", zErrMsg);
        sqlite3_free(zErrMsg);
    }
 
    // 插入数据
    sql = "INSERT INTO people (name, age, address) VALUES ('Alice', 30, 'Wonderland');";
    rc = sqlite3_exec(db, sql, callback, 0, &zErrMsg);
 
    // 查询数据
    sql = "SELECT * FROM people;";
    rc = sqlite3_exec(db, sql, callback, 0, &zErrMsg);
 
    sqlite3_close(db);
    return 0;
}

确保在编译时链接SQLite3库：




gcc your_program.c -lsqlite3 -o your_program

这个例子展示了如何打开一个SQLite数据库，创建一个表，插入数据，以及查询数据。在实际应用中，你可能需要添加错误处理和其他逻辑以确保程序的健壮性。

- 阅读更多 -

微服务 Spring Boot 整合 Redis BitMap 实现签到与统计

System

2024-09-04

所有,redis




import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.stereotype.Service;
 
@Service
public class SignService {
 
    @Autowired
    private StringRedisTemplate redisTemplate;
 
    @Autowired
    private DefaultRedisScript<Long> signScript;
 
    // 用户签到方法
    public boolean sign(String userId, String date) {
        // 使用BitMap记录用户签到情况，一天使用一个Bit
        String key = "sign_bitmap:" + date;
        Long result = redisTemplate.execute(signScript, Collections.singletonList(key), userId);
        return result != null && result == 1;
    }
 
    // 统计签到用户数方法
    public long countSign(String date) {
        String key = "sign_bitmap:" + date;
        // 使用Redis命令计算BitMap中值为1的个数
        return redisTemplate.execute((RedisCallback<Long>) con -> {
            byte[] keyByte = con.getByteName(key);
            return con.bitCount(keyByte);
        });
    }
}

这个代码实例展示了如何在Spring Boot应用中使用Redis的BitMap实现用户的签到以及签到用户数的统计。sign方法负责用户的签到操作，使用了一个Redis脚本来原子地将用户ID对应的位设置为1。countSign方法则用于统计某一天签到用户的数量，它通过Redis的BITCOUNT命令来实现。

System

2024-09-04

所有,数据库

错误解释：

django.db.utils.NotSupportedError: MySQL 表明 Django 在与 MySQL 数据库交互时遇到了不支持的操作错误。这可能是因为你尝试使用了MySQL不支持的特性，或者是Django的ORM与MySQL版本不兼容。

解决方法：

检查你的数据库操作是否使用了MySQL不支持的特性。
确保你的Django版本与MySQL数据库版本兼容。如果你使用的Django版本对应的ORM有对MySQL的特定支持，你需要确保你的MySQL版本与Django版本兼容。
如果你在使用Django的数据库迁移功能（migrations），请确保所有的迁移文件都已经应用，并且没有任何未解决的迁移问题。
如果问题依然存在，尝试更新MySQL到最新版本，或者更换到另一个与你的Django版本兼容的数据库系统，如PostgreSQL或SQLite。
查看Django的官方文档中关于数据库设置的指导，确保所有配置都正确无误。
如果你已经确认是MySQL版本问题，那么升级MySQL到兼容的版本。
如果你不能升级MySQL，考虑降级Django到一个与你当前MySQL版本兼容的版本。

务必在做任何更改前备份重要数据。

- 阅读更多 -

探索Django与Jaeger的融合：打造高效分布式追踪系统

System

2024-09-04

所有,数据库




from opentracing.ext import tags
from jaeger_client import Config
 
# 初始化Jaeger跟踪器
def init_tracer(service_name):
    config = Config(
        config={'sampler': {'type': 'const', 'param': 1},
                'logging': True,
                'local_agent': {'reporting_host': 'localhost', 'reporting_port': 6831},
                'service_name': service_name},
        service_name=service_name)
    return config.initialize_tracer()
 
# Django视图中的Jaeger跟踪示例
from django.http import HttpResponse
from django.views.decorators.http import require_http_methods
from jaeger_client.span import Span
from jaeger_client.tracer import Tracer
 
# 初始化Jaeger跟踪器
tracer = init_tracer('django-service')
 
@require_http_methods(['GET'])
def index(request):
    # 创建一个新的跟踪
    with tracer.start_span('index-view-span') as span:
        span.set_tag(tags.COMPONENT, 'django')
        span.set_tag(tags.HTTP_METHOD, 'GET')
        span.set_tag(tags.HTTP_URL, 'http://localhost:8000/')
 
        # 执行视图逻辑
        return HttpResponse('Hello, World!')

这段代码展示了如何在Django视图中使用Jaeger来跟踪请求。首先，我们定义了一个初始化Jaeger跟踪器的函数，并在Django的视图中使用with语句来创建一个新的跟踪，并为跟踪设置了必要的标签。这样，每当有请求到达首页时，都会生成一个新的跟踪记录，并且可以在Jaeger UI中查看和分析这些请求的追踪信息。

- 阅读更多 -

nginx和tomcat负载均衡，动静分离

System

2024-09-04

所有,java

为了实现Nginx与Tomcat的负载均衡，并进行动静分离，你需要做以下配置：

配置Nginx作为反向代理服务器，将静态内容由Nginx处理，动态请求代理到Tomcat服务器。
配置Tomcat服务器，确保它可以处理动态请求。

以下是Nginx的配置示例：




# nginx.conf 或在 server 块中
 
# 定义Tomcat服务器
upstream tomcat_server {
    server tomcat1.example.com:8080;
    server tomcat2.example.com:8080;
}
 
server {
    listen       80;
    server_name  localhost;
 
    # 静态文件目录
    location /static/ {
        root   /path/to/static/files;
        expires 30d;
    }
 
    # 所有其他请求代理到Tomcat服务器
    location / {
        proxy_pass http://tomcat_server;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

在这个配置中，upstream 块定义了一个名为 tomcat_server 的服务器组，包含了多个Tomcat服务器实例。在 server 块中，所有静态文件请求被直接由Nginx处理，并将其他所有请求代理到Tomcat服务器。

确保Tomcat服务器正常运行，并且Nginx配置文件没有语法错误，然后重启Nginx服务器以应用这些更改。

注意：以上配置示例假设你有多个Tomcat服务器实例，并且静态文件存储在本地文件系统中。根据你的实际部署环境，你可能需要调整 upstream 块中的服务器地址、root 指令中的静态文件路径，以及其他相关配置。

System

2024-09-04

所有,java




import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
 
@Component
public class WebsocketAndApiForwardingFilter implements GlobalFilter, Ordered {
 
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
 
        // 检查是否为Websocket请求
        if (isWebsocketRequest(request)) {
            // 这里可以添加处理Websocket请求的逻辑
            return handleWebsocketRequest(exchange);
        }
 
        // 继续处理API请求
        return chain.filter(exchange);
    }
 
    private boolean isWebsocketRequest(ServerHttpRequest request) {
        // 检查请求头中的Upgrade字段，查看是否为Websocket请求
        return "websocket".equalsIgnoreCase(request.getHeaders().getUpgrade());
    }
 
    private Mono<Void> handleWebsocketRequest(ServerWebExchange exchange) {
        // 这里实现转发Websocket请求的逻辑
        // 例如，可以直接返回一个特定的响应或者调用特定的服务处理
        return Mono.empty(); // 暂时返回一个空的Mono，表示不做任何处理
    }
 
    @Override
    public int getOrder() {
        // 设置过滤器的顺序，数字越小，优先级越高
        return -1;
    }
}

这个代码示例展示了如何检查是否为Websocket请求，并根据请求类型来转发或处理请求。这个过滤器可以被添加到Spring Cloud Gateway中，用于实现基于请求类型的路由分发。

- 阅读更多 -