分类后端技术下的文章

2024-09-03

Redis是一个开源的使用C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。

安装与使用

Redis可以在其官方网站上下载，解压后，进入redis目录，编译源码：




make

编译后，在src目录下，有几个可执行文件redis-server、redis-cli等，运行Redis服务：




./redis-server

在另一个终端运行Redis客户端：




./redis-cli

在Redis客户端，可以执行Redis命令，如：




set key value
get key

数据类型

Redis支持的数据类型包括字符串、列表、集合、有序集合、哈希表等。

例如，在Redis客户端执行：




# 字符串
set mykey "Hello"
get mykey
 
# 列表
lpush mylist a b c
lrange mylist 0 -1
 
# 集合
sadd myset "Hello" "World"
smembers myset
 
# 有序集合
zadd myzset 1 "one"
zrange myzset 0 -1 withscores
 
# 哈希表
hset myhash field1 "Hello"
hget myhash field1

持久化

Redis支持两种持久化方式，RDB（默认）和AOF。

RDB，在指定的时间间隔内将内存中的数据集快照写入磁盘，也就是Snapshotting。

AOF，保存Redis服务器所执行的所有写操作命令到文件。

可以在redis.conf中配置持久化：




# RDB
save 900 1
save 300 10
save 60 10000
 
# AOF
appendonly yes
appendfsync everysec

事务

Redis的事务可以一次执行多个命令，本身是串行的，但不保证原子性。




multi
set key1 value1
set key2 value2
exec

发布/订阅

Redis的发布/订阅机制允许客户端订阅一个或多个频道，发送消息到频道，其他订阅了该频道的客户端会收到消息。




# 订阅频道
subscribe mychannel
 
# 发布消息
publish mychannel "Hello World"

主从同步

Redis支持主从同步，从服务器自动同步主服务器的数据。

在redis.conf中配置：




slaveof <master-ip> <master-port>

分片

Redis支持分片，即分布式存储数据。

可以通过Redis Cluster或者客户端分片来实现。

安全性

Redis支持使用密码和TLS/SSL来保证安全性。

在redis.conf中配置：




requirepass yourpassword
 
tls-port 6379

在客户端连接时使用AUTH命令：




auth yourpassword

性能

Redis使用了单线程模型，基于内存操作，读写速度非常快。

应用场景

Redis可以应用在缓存、排行榜、计数器、分布式会话、分布式锁等场景。

例如，使用Redis做缓存：




import redis
 
r = redis.Red

- 阅读更多 -

如何部署项目到Tomcat + 第一个Servlet程序

System

2024-09-03

所有,java

要部署一个Servlet项目到Tomcat并运行第一个Servlet程序，请按照以下步骤操作：

确保你已经安装了Java Development Kit (JDK) 和 Apache 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类。




javac HelloWorldServlet.java

打包编译后的类文件到一个.war文件。
你可以手动创建一个WEB-INF文件夹和一个web.xml文件来部署你的Servlet，或者使用命令行工具如jar来打包。




jar cvf HelloWorld.war HelloWorldServlet.class

将生成的.war文件复制到Tomcat的webapps目录下。
启动Tomcat服务器。




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

访问Servlet。
打开浏览器，访问 http://localhost:8080/HelloWorld/HelloWorldServlet，你应该能看到“Hello World”的消息。

注意：如果你的Servlet类依赖于其他类或者库，你需要确保这些依赖也被打包到.war文件中。

- 阅读更多 -

Redis7_17 高阶篇第八章手写Redis的分布式锁（基础版）

System

2024-09-03

所有,redis




import redis
import uuid
import time
 
class SimpleRedLock:
    def __init__(self, connections):
        # 连接列表，应该是三个或者更多的Redis连接
        self.connections = connections
        self.retry_count = 3
        self.retry_delay = 2
        self.lock_ttl = 10
 
    def _generate_lock_key(self, resource):
        # 生成唯一的锁名
        return f"redlock:{resource}"
 
    def _acquire_lock(self, connection, lock_key, lock_value, lock_ttl):
        # 尝试在单个Redis实例上获取锁
        return connection.set(lock_key, lock_value, ex=lock_ttl, nx=True)
 
    def _release_lock(self, connection, lock_key, lock_value):
        # 释放锁的模板方法，可以根据需要进行扩展
        script = f"if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end"
        lock_key_b = bytes(lock_key, encoding='utf-8')
        lock_value_b = bytes(lock_value, encoding='utf-8')
        return connection.eval(script, 1, lock_key_b, lock_value_b)
 
    def lock(self, resource):
        # 获取锁的主函数
        lock_key = self._generate_lock_key(resource)
        lock_value = str(uuid.uuid4())
        attempts = 0
        while attempts < self.retry_count:
            for conn in self.connections:
                if self._acquire_lock(conn, lock_key, lock_value, self.lock_ttl):
                    # 如果在大多数节点上获取锁成功，则返回锁对象
                    return SimpleRedLockInstance(self, lock_key, lock_value, conn)
            time.sleep(self.retry_delay)
            attempts += 1
        return False
 
class SimpleRedLockInstance:
    def __init__(self, redlock, lock_key, lock_value, connection):
        self.redlock = redlock
        self.lock_key = lock_key
        self.lock_value = lock_value
        self.connection = connection
 
    def unlock(self):
        # 释放锁的方法
        return self.redlock._release_lock(self.connection, self.lock_key, self.lock_value)
 
# 使用示例
if __name__ == "__main__":
    # 假设有三个Redis连接
    redis_connections = [redis.Redis(host=host, port=port) for host, port in [("localhost", 6379), ("localhost", 6380), ("localhost", 6381)]]
    redlock = SimpleRedLock(redis_connections)
 
    lock_instance = redlock.lock("my_resource")
    if lock_instance:
        try:
            # 在这里执行需要锁保护的代码
            print("Acquired lock. Doing some work...")
        finally:
            # 释放锁
            lock_instance.unlock()

这个简化版本的Redis分布式锁实现了基本的锁定和解锁功能。它使用Redis SET命令的NX选项来确保只有一个客户端可以获得锁，并通过

- 阅读更多 -

SQLite高级语句查询

System

2024-09-03

所有,数据库

在SQLite中，进行复杂查询通常涉及到JOIN操作、子查询、聚合函数和窗口函数等。以下是一些示例：

使用JOIN连接两个表：




SELECT Orders.orderID, Customers.customerName
FROM Orders
JOIN Customers ON Orders.customerID = Customers.customerID;

使用子查询：




SELECT orderID, customerID
FROM Orders
WHERE customerID = (SELECT customerID FROM Customers WHERE customerName = 'Apple');

使用聚合函数（如COUNT、SUM、AVG）：




SELECT productName, COUNT(*)
FROM OrderDetails
GROUP BY productName;

使用窗口函数（如ROW\_NUMBER、RANK、DENSE\_RANK）：




SELECT productName, price,
       ROW_NUMBER() OVER (ORDER BY price DESC) AS rank
FROM Products;

确保表和字段名称是正确的，并根据实际数据库结构调整查询语句。

- 阅读更多 -

将Django的数据库源从MySQL切换到SQLite

System

2024-09-03

所有,数据库

为了将Django项目的数据库从MySQL切换到SQLite，你需要进行以下步骤：

修改项目的settings.py文件，将数据库配置改为SQLite。




# settings.py
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',
    }
}

如果你的MySQL数据库中有数据，你需要先将数据导出为SQL文件，然后再导入到SQLite。

导出MySQL数据的命令可能如下：




mysqldump -u [username] -p[password] [database_name] > data.sql

然后，你需要将SQL文件转换为SQLite可以理解的格式，可以使用mysql2sqlite工具。




mysql2sqlite data.sql | sqlite3 db.sqlite3

或者手动在SQLite数据库中执行转换后的SQL文件。

确保你的models.py中的模型与SQLite兼容，因为不同数据库之间可能存在差异。
清除Django的缓存。




python manage.py clearcache

迁移数据库模式。




python manage.py makemigrations
python manage.py migrate

确保在迁移前你已经创建了SQLite数据库文件db.sqlite3，并且它对Django项目是可写的。

System

2024-09-03

所有,数据库

报错问题：“LOCAL\_LISTENER”参数导致业务无法连接数据库。

解释：

LOCAL_LISTENER是Oracle数据库的参数之一，用于指定本地的监听程序。监听程序是Oracle Net Services中的一部分，负责监听和管理数据库客户端和数据库实例之间的网络连接请求。如果LOCAL_LISTENER参数配置不正确，就可能导致客户端无法正确连接到数据库实例。

解决方法：

检查监听配置是否正确：
- 使用lsnrctl status命令检查监听状态。
- 确认监听配置文件（listener.ora）中的HOST和PORT设置是否正确。
确认LOCAL_LISTENER参数设置：
- 使用SELECT * FROM V$PARAMETER WHERE NAME = 'local_listener';查询LOCAL_LISTENER参数的当前设置。
- 如果设置不正确，可以通过ALTER SYSTEM SET LOCAL_LISTENER = '(ADDRESS=(PROTOCOL=TCP)(HOST=你的主机名或IP)(PORT=你的端口号))'来修正它。
重启监听服务：
- 使用lsnrctl stop停止监听，然后用lsnrctl start来重启监听。
确认网络连通性：
- 检查客户端和数据库服务器之间的网络连接是否正常。
检查数据库实例状态：
- 确保数据库实例正在运行，可以使用SELECT STATUS FROM V$INSTANCE;查询。
查看错误日志：
- 检查数据库的错误日志和监听日志，以获取更多关于连接问题的信息。
如果问题依然存在，考虑咨询Oracle支持获取专业帮助。

- 阅读更多 -

Golang encoding 包详解

System

2024-09-03

所有,golang

encoding 包在 Go 语言中是一个非常重要的包，它提供了对多种编码和压缩算法的支持。这个包包含了对 base32, base64, gob, json, xml 等编码格式的支持。

以下是一些使用 encoding 包的常见方法：

Base64 编码和解码

Base64 是一种常用的编码格式，可以将二进制数据转换为只包含 A-Z, a-z, 0-9, +, / 字符的文本。




package main
 
import (
    "encoding/base64"
    "fmt"
)
 
func main() {
    // 编码
    data := "Hello, world!"
    encoded := base64.StdEncoding.EncodeToString([]byte(data))
    fmt.Println(encoded)
 
    // 解码
    decoded, err := base64.StdEncoding.DecodeString(encoded)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println(string(decoded))
}

Base32 编码和解码

Base32 和 Base64 类似，但它使用了一组大小为 32 的字符集。




package main
 
import (
    "encoding/base32"
    "fmt"
)
 
func main() {
    // 编码
    data := "Hello, world!"
    encoded := base32.StdEncoding.EncodeToString([]byte(data))
    fmt.Println(encoded)
 
    // 解码
    decoded, err := base32.StdEncoding.DecodeString(encoded)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println(string(decoded))
}

Gob 编码和解码

Gob 是 Go 语言特有的一种编码格式，主要用于序列化和反序列化数据。




package main
 
import (
    "bytes"
    "encoding/gob"
    "fmt"
    "log"
)
 
func main() {
    // 准备数据
    type Message struct {
        Name string
        Body string
        Time int64
    }
    original := Message{"Hello", "Hello, world!", 0}
 
    // 编码
    buffer := &bytes.Buffer{}
    encoder := gob.NewEncoder(buffer)
    err := encoder.Encode(original)
    if err != nil {
        log.Fatal(err)
    }
 
    // 解码
    decoded := Message{}
    decoder := gob.NewDecoder(buffer)
    err = decoder.Decode(&decoded)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(decoded)
}

JSON 编码和解码

JSON 是一种常用的数据交换格式，可以轻松地在不同的编程语言之间交换数据。




package main
 
import (
    "encoding/json"
    "fmt"
    "log"
)
 
func main() {
    // 准备数据
    type Message struct {
        Name string
        Body string
        Time int64
    }
    original := Message{"Hello", "Hello, world!", 0}
 
    // 编码
    jsonBytes, err := json.Marshal(original)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(string(jsonBytes))
 
    // 解码
    decoded := Message{}
    err = json.Unmarshal(jsonBytes, &decoded)
    i

- 阅读更多 -

Python操作SQLite指南

System

2024-09-03

所有,数据库




import sqlite3
 
# 连接到SQLite数据库
# 数据库文件是 test.db，如果文件不存在，会自动在当前目录创建:
conn = sqlite3.connect('test.db')
 
# 创建一个Cursor:
cursor = conn.cursor()
 
# 执行一条SQL语句，创建user表:
cursor.execute('CREATE TABLE IF NOT EXISTS user (id VARCHAR(20) PRIMARY KEY, name VARCHAR(20))')
 
# 关闭Cursor:
cursor.close()
 
# 执行查询语句，查询user表的所有数据:
cursor = conn.cursor()
cursor.execute('SELECT * FROM user')
values = cursor.fetchall()
print(values)
 
# 使用参数化查询来防止SQL注入:
cursor.execute('INSERT INTO user (id, name) VALUES (?, ?)', ('001', 'Alice'))
 
# 提交事务:
conn.commit()
 
# 关闭Cursor和Connection:
cursor.close()
conn.close()

这段代码展示了如何使用Python的sqlite3库来连接SQLite数据库、创建表格、执行查询以及防止SQL注入。代码简洁明了，并在每个关键步骤后都有解释。

System

2024-09-03

所有,数据库

报错解释：

这个错误表明PostgreSQL数据库遇到了一个问题，它要求wal_level配置参数至少需要设置为logical。wal_level控制着数据库的Write-Ahead Logging（WAL）记录的详细程度，这对于数据恢复和复制是非常重要的。在PostgreSQL中，logical级别的wal_level允许逻辑订阅和复制。

解决方法：

登录到PostgreSQL数据库服务器。
打开PostgreSQL的配置文件postgresql.conf。
找到wal_level配置项，并将其设置为logical。
重启PostgreSQL服务以使更改生效。

例子：

在postgresql.conf中，你可能会看到类似这样的行：




# wal_level = minimal

你需要将其更改为：




wal_level = logical

然后，重启PostgreSQL服务：




# 在Linux系统上，可能需要使用service或者systemctl，取决于你的系统
sudo service postgresql restart
# 或者
sudo systemctl restart postgresql

确保在修改配置文件和重启服务之前，你已经做好了适当的备份，并且了解如何检查配置是否成功更改。如果你不是数据库管理员，你可能需要联系你的数据库管理员来进行这些更改。

- 阅读更多 -

实验2 Oracle 数据库模式对象管理

System

2024-09-03

所有,数据库




-- 创建一个新的用户模式
CREATE SCHEMA my_schema AUTHORIZATION my_user;
 
-- 在新模式中创建一个表
CREATE TABLE my_schema.my_table (
    id NUMBER PRIMARY KEY,
    name VARCHAR2(50)
);
 
-- 在新模式中创建一个视图
CREATE VIEW my_schema.my_view AS
SELECT id, name FROM my_schema.my_table;
 
-- 在新模式中创建一个序列
CREATE SEQUENCE my_schema.my_sequence
START WITH 1
INCREMENT BY 1
NOMAXVALUE;
 
-- 在新模式中创建一个存储过程
CREATE OR REPLACE PROCEDURE my_schema.my_procedure
IS
BEGIN
    -- 这里可以编写PL/SQL代码逻辑
    NULL; -- 这里仅仅是一个占位符，实际中应该有具体的过程代码
END my_procedure;
/
 
-- 在新模式中创建一个函数
CREATE OR REPLACE FUNCTION my_schema.my_function
RETURN NUMBER
IS
BEGIN
    -- 这里可以编写返回数字的PL/SQL逻辑
    RETURN 0; -- 这里仅仅是一个占位符，实际中应该有具体的函数代码
END my_function;
/
 
-- 在新模式中创建一个触发器
CREATE OR REPLACE TRIGGER my_schema.my_trigger
BEFORE INSERT ON my_schema.my_table
FOR EACH ROW
BEGIN
    -- 这里可以编写触发器逻辑
    NULL; -- 这里仅仅是一个占位符，实际中应该有具体的触发器代码
END my_trigger;
/

以上代码展示了如何在Oracle数据库中创建一个新的用户模式，并在该模式下创建表、视图、序列、存储过程、函数和触发器。每一段代码都是独立的，可以直接在Oracle数据库中执行。在实际应用中，需要根据具体需求替换模式名、用户名、表名、视图名、序列名、过程名、函数名和触发器名，并填充相应的逻辑代码。

- 阅读更多 -