System 发布的文章

2024-09-03

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

Spring Cloud Alibaba Sentinel 为 Spring Cloud 用户提供了便捷的整合方式。

以下是一个使用 Sentinel 和 Spring Cloud 整合的简单示例：

在 pom.xml 中添加依赖：




<dependencies>
    <!-- Spring Cloud Alibaba Sentinel -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
    </dependency>
    <!-- 其他依赖... -->
</dependencies>

在 application.yml 或 application.properties 中配置 Sentinel 控制台地址和应用信息：




spring:
  cloud:
    sentinel:
      transport:
        dashboard: 127.0.0.1:8080 # Sentinel 控制台地址
        port: 8719 # 默认端口，可以不配置
      # 应用名称，显示在 Sentinel 控制台
      app:
        name: my-spring-cloud-app

创建一个 REST 控制器，并添加需要被保护的资源：




@RestController
public class TestController {
 
    @GetMapping("/test")
    @SentinelResource("test") // 定义资源
    public String test() {
        return "Hello, Sentinel!";
    }
}

启动应用，访问 /test 接口，并观察 Sentinel 控制台的效果。

以上是一个非常简单的 Sentinel 和 Spring Cloud 整合示例。在实际应用中，你可能需要根据具体需求进行流量控制、熔断降级等策略的配置。

- 阅读更多 -

CentOS 7 上编译和安装 SQLite 3.9.0

System

2024-09-03

所有,数据库




#!/bin/bash
# 安装 SQLite 3.9.0 的脚本
 
# 定义源码目录和安装目录
SOURCE_DIR=/path/to/sqlite-src
INSTALL_DIR=/path/to/sqlite-install
 
# 创建安装目录
mkdir -p $INSTALL_DIR
 
# 下载 SQLite 3.9.0 源码
curl -o sqlite-autoconf-3090000.tar.gz http://www.sqlite.org/sqlite-autoconf-3090000.tar.gz
 
# 解压源码包
tar xf sqlite-autoconf-3090000.tar.gz
 
# 编译和安装
cd sqlite-autoconf-3090000
./configure --prefix=$INSTALL_DIR
make
make install
 
# 清理工作
cd ..
rm -rf sqlite-autoconf-3090000
rm sqlite-autoconf-3090000.tar.gz

这段脚本展示了如何从源代码下载、解压、编译和安装 SQLite 3.9.0 版本的基本步骤。脚本首先定义了源码目录和安装目录，然后创建安装目录。接着，脚本下载 SQLite 源码压缩包，解压后进入目录，执行配置、编译和安装步骤。最后，清理工作包括删除源码目录和源码压缩包。

- 阅读更多 -

redis-读懂redis

System

2024-09-03

所有,redis

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注入。代码简洁明了，并在每个关键步骤后都有解释。

- 阅读更多 -