分类后端技术下的文章

2024-09-09

在Linux系统中安装PostgreSQL数据库的步骤通常如下：

更新系统包索引：

sudo apt update

安装PostgreSQL：

sudo apt install postgresql postgresql-contrib

启动PostgreSQL服务：

sudo systemctl start postgresql

确保PostgreSQL随系统启动：

sudo systemctl enable postgresql

切换到PostgreSQL用户（默认为postgres）：

sudo -i -u postgres

创建一个新的角色（可选）：

createuser --interactive

创建一个新数据库（可选）：

createdb <your_database_name>

登录到PostgreSQL命令行界面：

psql

以上步骤适用于基于Debian的系统，如Ubuntu。对于基于RPM的系统，如CentOS，步骤可能略有不同。

请根据您的操作系统和需求调整上述命令。如果您需要图形界面安装程序，可以使用apt-get install postgresql-12（版本号根据实际情况选择），然后按照向导进行操作。

- 阅读更多 -

【Spring Cloud Alibaba】开源组件Sentinel

System

2024-09-09

所有,java

Sentinel 是阿里巴巴开源的面向分布式服务架构的轻量级流量控制框架，主要以流量为切入点，提供多维度的流量控制、熔断降级、系统负载保护等功能。

以下是一个使用 Sentinel 的简单示例，演示如何在 Spring Cloud 应用中集成 Sentinel 来实现流量控制。

在 pom.xml 中添加 Sentinel 依赖：

<dependencies>
    <!-- Sentinel 核心库 -->
    <dependency>
        <groupId>com.alibaba.csp</groupId>
        <artifactId>sentinel-core</artifactId>
        <version>1.8.0</version>
    </dependency>
    <!-- Sentinel API 模块 -->
    <dependency>
        <groupId>com.alibaba.csp</groupId>
        <artifactId>sentinel-api-ds</artifactId>
        <version>1.8.0</version>
    </dependency>
</dependencies>

在代码中定义资源并配置规则：

import com.alibaba.csp.sentinel.Entry;
import com.alibaba.csp.sentinel.SphU;
import com.alibaba.csp.sentinel.slots.block.RuleConstant;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;

import java.util.ArrayList;
import java.util.List;

public class SentinelDemo {

    private static final String RESOURCE_KEY = "myResource";

    public static void main(String[] args) {
        initFlowRules();

        while (true) {
            //  entry 方法将会执行资源的访问.
            try (Entry entry = SphU.entry(RESOURCE_KEY)) {
                // 被保护的代码
                System.out.println("Hello Sentinel!");
            } catch (Exception e) {
                // 处理异常
                System.out.println("Sentinel limiting!");
            }

            // 每秒执行一次
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private static void initFlowRules() {
        List<FlowRule> rules = new ArrayList<>();
        FlowRule rule = new FlowRule();
        rule.setResource(RESOURCE_KEY);
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        // Set limit QPS to 20.
        rule.setCount(20);
        rules.add(rule);

        FlowRuleManager.loadRules(rules);
    }
}

在这个例子中，我们定义了一个名为 "myResource" 的资源，并且初始化了一个流量控制规则，限制每秒钟的访问量不超过 20 次。在 while 循环中，我们持续地调用 SphU.entry() 方法访问这个资源，并且处理了可能发生的异常。如果访问频率超过规定的限制，Sentinel 会抛出异常，并执行异常块中的代码。

这只是 Sentinel 使用的简单示例，Sentinel 提供了更多高级特性，如系统保护、熔断降级等，需要结合实际业务场景进行使用和配置。

System

2024-09-09

所有,数据库

#include "postgres.h"
#include "knl/knl_variable.h"

/* 定义一个示例的增量备份记录结构体 */
typedef struct IncrementalBackupRecord {
    TimestampTz start_time; /* 备份开始时间 */
    TimestampTz end_time;   /* 备份结束时间 */
    char *backup_mode;      /* 备份模式，例如FULL, INCREMENTAL */
    /* 其他必要的备份信息字段 */
} IncrementalBackupRecord;

/* 创建一个新的增量备份记录 */
IncrementalBackupRecord *
CreateIncrementalBackupRecord(TimestampTz start, TimestampTz end, const char *mode)
{
    IncrementalBackupRecord *record = (IncrementalBackupRecord *)malloc(sizeof(IncrementalBackupRecord));
    if (record == NULL) {
        ereport(ERROR, (errcode(ERRCODE_OUT_OF_MEMORY), errmsg("out of memory when creating incremental backup record")));
    }
    record->start_time = start;
    record->end_time = end;
    record->backup_mode = strdup(mode);
    if (record->backup_mode == NULL) {
        free(record);
        ereport(ERROR, (errcode(ERRCODE_OUT_OF_MEMORY), errmsg("out of memory when duplicating backup mode")));
    }
    return record;
}

/* 释放增量备份记录 */
void FreeIncrementalBackupRecord(IncrementalBackupRecord *record)
{
    if (record == NULL) {
        return;
    }
    pfree(record->backup_mode);
    free(record);
}

/* 使用增量备份记录的例子 */
void ExampleUsage()
{
    TimestampTz start = GetCurrentTimestamp();
    TimestampTz end = GetCurrentTimestamp();
    const char *mode = "INCREMENTAL";
    IncrementalBackupRecord *record = CreateIncrementalBackupRecord(start, end, mode);

    // 使用record进行备份相关的操作...

    FreeIncrementalBackupRecord(record);
}

这个代码示例展示了如何在C语言中定义一个简单的增量备份记录结构体，并实现创建和释放这种记录的函数。它还提供了一个使用这些函数的简单例子。这个示例假设存在GetCurrentTimestamp和ereport函数，这些函数在实际的openGauss数据库环境中会有相应的实现。

- 阅读更多 -

Redis入门到实战（虎哥版）个人笔记-高级篇“分布式缓存”

System

2024-09-09

所有,redis

在分布式系统中，缓存是常用的提高性能的手段之一。Redis作为一种内存数据结构存储系统，可以用来作为分布式缓存。

一、Redis集群的数据分片机制

Redis Cluster采用虚拟槽(hash slot)的机制，所有的键根据[0-16383]个整数映射，用哈希函数HASH\_SLOT=CRC16(key) mod 16384来实现。每个节点负责维护一部分槽以及映射的键值数据。

二、Redis集群的数据迁移

Redis Cluster的数据迁移通过Redis Cluster rebalance工具进行。

三、Redis集群的可用性

Redis Cluster可用性保证取决于集群中master的数量，至少需要一个。如果一个master失效，它的slave会接管。

四、Redis集群的一致性保证

Redis Cluster通过使用Paxos协议实现数据的最终一致性。

五、Redis集群的可靠性

Redis Cluster的可靠性依赖于大多数节点可用，至少需要有一半以上的节点可用，才能对外提供服务。

六、Redis集群的主从切换

当主节点失效时，Redis Cluster会从从节点中选举一个新的主节点。

七、Redis集群的动态扩容

可以动态添加新的节点到集群，并且可以重新分配槽位。

八、Redis集群的动态缩容

可以动态移除节点，并重新分配槽位。

以上是分布式缓存的一些基本概念和处理方式，在实际应用中，还需要考虑数据的一致性、可靠性、可用性等问题，并根据实际需求进行调整和优化。

- 阅读更多 -

Python 之 Django框架 - 基础数据篇

System

2024-09-09

所有,数据库

# 导入Django数据库相关模块
from django.db import models

# 创建一个名为Book的数据模型
class Book(models.Model):
    # 书籍名称，字符串类型，最大长度50，不允许为空
    title = models.CharField(max_length=50, blank=False)
    # 作者名称，字符串类型，最大长度50，允许为空
    author = models.CharField(max_length=50, blank=True)
    # 出版日期，日期类型
    pub_date = models.DateField()

    # 定义一个方法，用于返回书籍信息的字符串表示
    def __str__(self):
        return f"{self.title} by {self.author} on {self.pub_date}"

# 使用Django管理工具注册Book模型
admin.site.register(Book)

这段代码定义了一个简单的数据模型Book，包含书籍名称、作者名称和出版日期。同时，提供了一个方法__str__用于返回书籍信息的字符串表示，并且示例中展示了如何在Django管理后台注册这个模型。这有助于开发者理解如何在Django中创建数据模型并进行管理。

- 阅读更多 -

Mac下安装并配置jdk8环境

System

2024-09-09

所有,数据库

在Mac下安装并配置JDK 8环境，你可以按照以下步骤操作：

下载JDK 8:
访问Oracle官方网站下载JDK 8的安装包。你可能需要注册Oracle账号才能下载。
安装JDK:
打开下载的安装包，并按照提示进行安装。安装完成后，你可以在/Library/Java/JavaVirtualMachines/目录下找到类似jdk1.8.0_xxx.jdk的文件夹。
配置环境变量:
打开终端，并输入以下命令来编辑你的shell配置文件（如果你使用的是bash shell，则编辑.bash_profile; 如果使用的是zsh，则编辑.zshrc）：
```
nano ~/.bash_profile
```
Bash
或者使用你喜欢的任何文本编辑器来编辑该文件。
在打开的配置文件中，添加以下内容：
```
export JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk1.8.0_xxx.jdk/Contents/Home
export PATH=$PATH:$JAVA_HOME/bin
```
Bash
替换jdk1.8.0_xxx.jdk为你安装的JDK版本文件夹名称。
保存并关闭文件，然后在终端中运行以下命令来使配置生效：
```
source ~/.bash_profile
```
Bash
如果你编辑的是.zshrc，则应该运行source ~/.zshrc。
验证安装:
在终端中输入以下命令来验证JDK是否安装并配置正确：
```
java -version
```
Bash
如果正确安装，你将看到java版本输出为1.8.0\_xxx。

以上步骤会在你的Mac上配置JDK 8环境。

- 阅读更多 -

3月第三讲Spring Boot系列-集成mybatis

System

2024-09-09

所有,java

在Spring Boot项目中集成MyBatis，首先需要在项目的pom.xml中添加MyBatis和数据库驱动的依赖。以下是一个简化的例子：

<dependencies>
    <!-- Spring Boot相关依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- MyBatis依赖 -->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.1.4</version>
    </dependency>

    <!-- 数据库驱动，以MySQL为例 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.23</version>
    </dependency>

    <!-- 其他必要的依赖 -->
</dependencies>

接下来，在application.properties或application.yml中配置数据库连接信息和MyBatis的相关设置：

# 数据库连接信息
spring.datasource.url=jdbc:mysql://localhost:3306/your_database?useSSL=false&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=yourpassword
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# MyBatis 设置
mybatis.mapper-locations=classpath:mapper/*.xml
mybatis.type-aliases-package=com.yourpackage.model

创建Mapper接口和Mapper XML文件。例如：

// UserMapper.java
package com.yourpackage.mapper;

public interface UserMapper {
    User selectUserById(int id);
}

<!-- UserMapper.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yourpackage.mapper.UserMapper">
    <select id="selectUserById" parameterType="int" resultType="com.yourpackage.model.User">
        SELECT * FROM users WHERE id = #{id}
    </select>
</mapper>

在Spring Boot的主类或配置类中，通过@MapperScan注解指定Mapper接口的位置：

// YourApplication.java
package com.yourpackage;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("com.yourpackage.mapper")
public class YourApplication {
    public static void main(String[] args) {
        SpringApplication.run(YourApplication.class, args);
    }
}

最后，可以在Service层中注入Mapper并使用：

// UserService.java
package com.yourpackage.service;

import com.yourpackage.mapper.UserMapper;
import com.yourpackage.model.User;
import org.springframe

- 阅读更多 -

SQLite: 轻量级嵌入式数据库引擎的全面介绍

System

2024-09-09

所有,数据库

SQLite是一个开源的嵌入式数据库引擎，实现了多数SQL标准的一个子集，可以在许多小型设备上运行，如手机和平板电脑。它提供了一个轻量级的数据库解决方案，非常适合于那些没有专业数据库管理系统的应用。

以下是一个简单的Python代码示例，展示了如何使用SQLite创建一个数据库、表和执行基本的SQL操作：

import sqlite3

# 连接到SQLite数据库。如果数据库不存在，会自动创建：
conn = sqlite3.connect('example.db')

# 创建一个Cursor：
cursor = conn.cursor()

# 执行一条SQL语句，创建users表：
cursor.execute('CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, username TEXT, password TEXT)')

# 关闭Cursor：
cursor.close()

# 使用INSERT语句插入数据：
cursor = conn.cursor()
cursor.execute("INSERT INTO users (username, password) VALUES ('admin', 'admin')")
conn.commit()
cursor.close()

# 查询数据：
cursor = conn.cursor()
cursor.execute("SELECT * FROM users WHERE username = 'admin'")
rows = cursor.fetchall()
for row in rows:
    print(row)

# 关闭连接：
conn.close()

这段代码展示了如何在Python中使用SQLite进行基本的数据库操作，包括创建数据库、创建表、插入数据、查询数据和关闭数据库连接。在实际应用中，你可能还需要处理异常和更复杂的SQL查询，但这个示例提供了一个基本框架。

- 阅读更多 -

Spring Boot 整合 xxl-job 保姆级教程！

System

2024-09-09

所有,java

在Spring Boot中整合XXL-JOB的步骤如下：

添加XXL-JOB的依赖到你的pom.xml文件中：

<dependency>
    <groupId>com.xuxueli</groupId>
    <artifactId>xxl-job-core</artifactId>
    <version>你的版本号</version>
</dependency>

在application.properties或application.yml中配置XXL-JOB：

# xxl-job admin address
xxl.job.admin.addresses=你的XXL-JOB-ADMIN地址
# xxl.job executor appname
xxl.job.executor.appname=你的执行器名称
# xxl.job executor ip
xxl.job.executor.ip=自动获取可以为空
# xxl.job executor port
xxl.job.executor.port=你的执行器端口
# xxl.job access token
xxl.job.accessToken=你的访问令牌
# xxl.job executor logpath
xxl.job.executor.logpath=/data/applogs/xxl-job/jobhandler
# xxl.job executor logretentiondays
xxl.job.executor.logretentiondays=30

创建一个JobHandler类实现com.xxl.job.core.handler.IJobHandler接口：

@Component
public class SampleXxlJob implements IJobHandler {
    @Override
    public ReturnT<String> execute(String param) throws Exception {
        // 你的任务逻辑
        XxlJobLogger.log("这是一个XXL-JOB的示例");
        return ReturnT.SUCCESS;
    }
}

配置执行器Bean：

@Configuration
public class XxlJobConfig {

    @Value("${xxl.job.admin.addresses}")
    private String adminAddresses;

    @Value("${xxl.job.executor.appname}")
    private String appName;

    @Value("${xxl.job.executor.ip}")
    private String ip;

    @Value("${xxl.job.executor.port}")
    private int port;

    @Value("${xxl.job.accessToken}")
    private String accessToken;

    @Bean
    public XxlJobExecutor xxlJobExecutor() {
        XxlJobExecutor xxlJobExecutor = new XxlJobExecutor();
        // 设置admin地址
        xxlJobExecutor.setAdminAddresses(adminAddresses);
        // 设置执行器相关信息
        xxlJobExecutor.setAppName(appName);
        xxlJobExecutor.setIp(ip);
        xxlJobExecutor.setPort(port);
        xxlJobExecutor.setAccessToken(accessToken);
        return xxlJobExecutor;
    }
}

在Spring Boot启动类上添加@EnableXxlJob注解启用XXL-JOB：

@SpringBootApplication
@EnableXxlJob
public class YourApplication {
    public static void main(String[] args) {
        SpringApplication.run(YourApplication.class, args);
    }
}

在XXL-JOB的管理界面配置你的任务，指定执行器，并且设置相应的JobHandler类名称。

以上步骤完成后，你的Spring Boot应用就可以通过XXL-JOB执行定时任务了。

- 阅读更多 -

redis运维redis-cli命令

System

2024-09-09

所有,redis

Redis-cli是Redis自带的一个非常方便的命令行工具，可以用于连接Redis服务，并对Redis进行操作。

连接Redis服务

连接到Redis服务的最基本命令是：

redis-cli

如果Redis服务设置了密码，可以使用-a参数指定密码：

redis-cli -a password

如果Redis服务监听的端口不是默认的6379，可以使用-p参数指定端口：

redis-cli -p port

如果Redis服务监听的主机不是本地，可以使用-h参数指定主机：

redis-cli -h host

使用Redis命令

连接到Redis服务后，就可以使用Redis提供的命令对数据进行操作了。例如，设置一个key-value：

redis-cli set key value

获取一个key的值：

redis-cli get key

删除一个key：

redis-cli del key

查看所有的key：

redis-cli keys *

批量操作

如果你有一个文件，里面包含了很多的Redis命令，你可以使用--pipe参数将文件中的命令批量执行：

redis-cli --pipe commands.txt

导入导出数据

使用-r参数可以将命令的输出结果输出到文件中：

redis-cli -r 10 keys * > output.txt

使用-i参数可以将文件中的命令导入到Redis中执行：

redis-cli -i input.txt

其他参数

Redis-cli还有很多其他参数，例如-n参数可以让你执行命令时不输出命令回显，-t参数可以让你设置命令超时时间等。

使用脚本操作Redis

你可以将常用的Redis命令写入脚本，然后通过redis-cli执行脚本：

redis-cli < script.txt

以上就是Redis-cli的基本使用方法，更多高级用法可以查看Redis-cli的官方文档。

- 阅读更多 -