分类后端技术下的文章

2024-09-06

慢SQL诊断通常涉及以下步骤：

日志分析：查看数据库慢查询日志，找出执行时间超过阈值的SQL语句。
Explain分析：对慢SQL进行EXPLAIN或类似的分析，检查执行计划。
show processlist：使用SHOW PROCESSLIST查看当前运行的SQL语句和它们的资源消耗。
索引优化：检查SQL语句的索引使用情况，优化索引设计。
查询优化：重写或优化SQL查询语句，减少数据量和复杂度。
服务器资源：检查数据库服务器的CPU、内存、磁盘I/O等资源使用情况，确保硬件资源满足需求。
调整配置：根据需要调整数据库的配置参数，如查询缓存大小、排序缓冲区大小等。
定位慢查询代码：如果是应用程序导致，定位代码中的数据库操作并进行优化。

具体的SQL语句分析和优化取决于数据库类型和具体的慢查询语句。

Redis的安全性：最佳实践和常见防范策略

2024-09-06

所有,redis

Redis的安全性是非常重要的，因为它存储的数据可能包含敏感信息。以下是一些提高Redis安全性的最佳实践：

使用强密码：为Redis设置一个强密码，并确保它存储在安全的地方。




# 在redis.conf中设置密码
requirepass yourStrongPassword

使用TLS/SSL：为Redis服务器和客户端之间的通信启用TLS/SSL，这样可以确保数据在传输过程中的安全性。
监听地址：确保Redis只监听在信任的网络接口上。




# 在redis.conf中设置监听地址
bind 127.0.0.1

权限控制：使用rename-command配置来重命名或禁用某些危险命令，例如FLUSHALL、CONFIG等。




# 在redis.conf中重命名或禁用命令
rename-command CONFIG ""

限制内存使用：通过maxmemory配置限制Redis使用的最大内存，避免内存溢出攻击。




# 在redis.conf中设置最大内存
maxmemory 2gb

定期审计和监控：定期审计Redis的日志和监控工具，以发现可能的安全问题。
更新Redis：保持Redis的最新版本，以修复已知的安全漏洞。
配置防火墙：使用防火墙规则限制对Redis服务器的访问，仅允许必要的IP地址和端口通过。

这些措施可以组合使用，以提供更全面的安全保护。

【SpringBoot3】使用Jasypt加密数据库用户名、密码等敏感信息

2024-09-06




import org.jasypt.encryption.StringEncryptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
 
@Configuration
public class JasyptConfig {
 
    @Bean
    @Profile("!test") // 确保不在测试环境中运行
    public StringEncryptor stringEncryptor() {
        // 这里可以配置你的StringEncryptor的具体实现，比如使用默认的StrongStringEncryptor
        // 或者使用更安全的算法，比如配置自定义的加密器等
        org.jasypt.stronghold.StrongStringEncryptor strongEncryptor = new org.jasypt.stronghold.StrongStringEncryptor();
        strongEncryptor.setPassword("your-encryption-password"); // 设置加密密钥
        return strongEncryptor;
    }
}

在Spring Boot应用的配置文件中，使用Jasypt提供的EL表达式来引用加密的数据库凭据：




spring.datasource.username=ENC(your-encrypted-username)
spring.datasource.password=ENC(your-encrypted-password)

在上述配置中，ENC()是一个占位符，表示其内容是加密的。your-encrypted-username和your-encrypted-password应该是你使用StringEncryptor加密的字符串。

注意：在测试环境中，你可能不希望进行加密，因此可以通过设置Spring的Profile为test来避免在测试环境中配置加密的bean。

MongoDB随记

2024-09-06

由于您提出的问题是关于MongoDB的，但没有具体的问题描述，我将提供一些常见的MongoDB操作和查询的示例代码。

连接到MongoDB数据库：




from pymongo import MongoClient
 
client = MongoClient('mongodb://localhost:27017/')
db = client['mydatabase']

插入文档：




my_document = {'name': 'Alice', 'age': 25}
db.mycollection.insert_one(my_document)

查询文档：




# 查询所有文档
for doc in db.mycollection.find():
    print(doc)
 
# 查询特定文档
alice = db.mycollection.find_one({'name': 'Alice'})
print(alice)

更新文档：




db.mycollection.update_one({'name': 'Alice'}, {'$set': {'age': 26}})

删除文档：




db.mycollection.delete_one({'name': 'Alice'})

创建索引：




db.mycollection.create_index([('name', pymongo.ASCENDING)])

执行聚合查询：




pipeline = [
    {'$match': {'name': 'Alice'}},
    {'$group': {'_id': '$age', 'count': {'$sum': 1}}}
]
 
results = db.mycollection.aggregate(pipeline)
for result in results:
    print(result)

这些代码示例展示了如何使用Python的pymongo库来连接到MongoDB，进行基本的CRUD操作，以及创建索引和执行聚合查询。

MongoDB快速入门及其SpringBoot实战

2024-09-06




import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.stereotype.Service;
 
import java.util.List;
 
@Service
public class UserService {
 
    @Autowired
    private MongoTemplate mongoTemplate;
 
    public void createUser(User user) {
        mongoTemplate.save(user, "users");
    }
 
    public List<User> getAllUsers() {
        return mongoTemplate.findAll(User.class, "users");
    }
 
    public User getUserById(String id) {
        Query query = new Query(Criteria.where("id").is(id));
        return mongoTemplate.findOne(query, User.class, "users");
    }
 
    public void updateUser(User user) {
        Query query = new Query(Criteria.where("id").is(user.getId()));
        mongoTemplate.upsert(query, user, "users");
    }
 
    public void deleteUserById(String id) {
        Query query = new Query(Criteria.where("id").is(id));
        mongoTemplate.remove(query, User.class, "users");
    }
}

这段代码提供了一个简单的User服务类，用于与MongoDB的users集合进行交互。它展示了基本的创建、读取、更新和删除操作，这些操作对于任何使用MongoDB的应用程序都是常见且重要的。在Spring Boot应用程序中，你可以通过自动配置的MongoTemplate与MongoDB进行交互。

改动最小,最简洁的 tomcat catalina.out日志切割(按天)

2024-09-06

Tomcat 的 catalina.out 日志切割可以通过外部脚本来实现，以下是一个使用 Shell 脚本进行日志切割的简单示例：




#!/bin/bash
 
# 设置日志文件路径
LOG_FILE="/path/to/tomcat/logs/catalina.out"
 
# 设置切割后的日志文件前缀
LOG_PREFIX="/path/to/tomcat/logs/catalina.out."
 
# 使用 date 命令获取当前日期，并格式化为 YYYY-MM-DD
TODAY=$(date +%Y-%m-%d)
 
# 移动当前的 catalina.out 到切割文件，并清空原文件
mv $LOG_FILE $LOG_PREFIX$TODAY
touch $LOG_FILE
 
# 可以选择删除旧的日志文件，只保留最近 N 天的日志
DAYS_TO_KEEP=7
find $LOG_PREFIX* -mtime +$DAYS_TO_KEEP -exec rm {} \;

将上述脚本保存为 rotate_catalina.sh，并给予执行权限：




chmod +x rotate_catalina.sh

然后，你可以通过 cron 定时执行这个脚本，例如每天凌晨执行：




0 0 * * * /path/to/rotate_catalina.sh

确保 cron 任务中的路径是正确的，指向你的 Shell 脚本的实际路径。这样就可以实现每天定时切割 catalina.out 日志文件了。

2024-09-06

Spring Boot 整合 Canal 实现数据库同步，并在 MySQL 主库宕机时自动切换到从库，可以通过以下步骤实现：

配置 Canal 服务器，确保它能监听到主库的变更事件。
在 Spring Boot 应用中配置 Canal 客户端，连接到 Canal 服务器。
监听 Canal 服务器的变更事件，并在主库宕机时切换到从库。

以下是一个简化的示例代码：

配置 Canal 客户端：




canal:
  host: canal服务器地址
  port: 11111
  destination: example
  username: canal
  password: canal

Canal 监听器配置：




@Component
@Slf4j
public class DataChangeListener {
 
    @Autowired
    private CanalConnector connector;
 
    @PostConstruct
    public void start() {
        connector.connect();
        connector.subscribe();
        new Thread(this::listen).start();
    }
 
    private void listen() {
        while (true) {
            try {
                Message message = connector.getWithoutAck(1024); // 获取指定数量的数据
                long batchId = message.getId();
                if (batchId == -1 || message.getEntries().isEmpty()) {
                    // 没有数据或者已经获取完毕
                    Thread.sleep(1000);
                } else {
                    // 处理数据变更事件
                    for (Entry entry : message.getEntries()) {
                        if (EntryType.ROWDATA == entry.getEntryType()) {
                            // 对事件进行处理
                        }
                    }
                    connector.ack(batchId); // 确认消息已被处理
                }
            } catch (Exception e) {
                log.error("处理数据变更事件失败", e);
            }
        }
    }
}

主库宕机时切换逻辑：




public class CanalClient {
 
    private CanalConnector connector;
 
    public void connect(String host, int port, String destination) {
        connector = new CanalConnector(destination, host, port, "", "");
        connector.connect();
        connector.subscribe();
    }
 
    public void switchToSlave() {
        // 主库宕机时，切换到从库的逻辑
        // 可能需要重新配置连接信息，并重新调用 connect 方法
    }
 
    public void start() {
        while (true) {
            try {
                Message message = connector.getWithoutAck(1024); // 获取指定数量的数据
                if (message.getEntries().is

IDEA2023.1.4配置JavaWeb项目（JSP + Tomcat）

2024-09-06

在IntelliJ IDEA 2023.1.4中配置Java Web项目，你需要安装Java Development Kit (JDK)，配置好环境变量，并安装Apache Tomcat。以下是配置步骤的简要说明和示例：

安装JDK:
- 访问Oracle官网或者OpenJDK官网下载相应版本的JDK。
- 安装JDK，并配置JAVA_HOME环境变量指向JDK安装目录。
安装Apache Tomcat:
- 访问Apache Tomcat官网下载Tomcat。
- 解压Tomcat到指定目录。
- 配置CATALINA_HOME环境变量指向Tomcat安装目录。
打开IntelliJ IDEA，创建新项目:
- 选择"Create New Project"。
- 选择"Java Enterprise"。
- 选择"Web Application"并配置项目SDK、版本、以及Web框架（如Servlet）。
- 完成项目创建并等待IDE索引完成。
配置Tomcat:
- 打开"Run"菜单选择"Edit Configurations"。
- 点击"+"，选择"Tomcat Server"下的"Local"。
- 在"Server"选项卡中配置Tomcat服务器的路径，并创建一个新的部署。
- 在"Deployment"选项卡中配置Artifact。
编写JSP页面:
- 在web/WEB-INF/web.xml中配置JSP Servlet。
- 在web目录下创建JSP文件，例如index.jsp。
运行项目:
- 点击运行配置中的"Run"按钮，启动Tomcat服务器。
- 浏览器中访问http://localhost:8080查看JSP页面。

示例代码（web/WEB-INF/web.xml）:




<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                      http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
 
  <servlet>
    <servlet-name>jsp</servlet-name>
    <servlet-class>org.apache.jasper.servlet.JspServlet</servlet-class>
  </servlet>
 
  <servlet-mapping>
    <servlet-name>jsp</servlet-name>
    <url-pattern>*.jsp</url-pattern>
  </servlet-mapping>
 
</web-app>

示例代码（web/index.jsp）:




<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Hello JSP</title>
</head>
<body>
    <h1>Hello, World from JSP!</h1>
</body>
</html>

以上步骤和示例代码提供了一个基本的Java Web项目配置流程，包括JDK、Tomcat的安装和配置，以及一个简单的JSP页面的创建和运行。

linux下定时任务执行cron和日志转出logrotate

2024-09-06

在Linux下，可以使用cron来定期执行任务，而logrotate用于自动轮转、压缩、删除、和邮寄日志文件。

使用`cron`执行定时任务

编辑crontab文件：




crontab -e

添加定时任务，例如每天凌晨1点执行脚本：




0 1 * * * /path/to/your/script.sh

保存并退出编辑器。

示例`script.sh`脚本：




#!/bin/bash
echo "Task executed at $(date)" >> /path/to/your/logfile.log

确保script.sh有执行权限：




chmod +x /path/to/your/script.sh

配置`logrotate`

创建或编辑logrotate配置文件，通常位于/etc/logrotate.d/目录下，例如myapp-logrotate:




nano /etc/logrotate.d/myapp-logrotate

添加配置，例如每天轮转一次日志，保留7天的日志：




/path/to/your/logfile.log {
    daily
    rotate 7
    compress
    missingok
    notifempty
    create 640 root admin
}

保存文件并退出编辑器。

logrotate会根据配置自动处理日志文件，包括轮转、压缩、删除等。

postgresql内核源码分析-删除表drop table流程

2024-09-06

在PostgreSQL中，删除表的操作是通过DropTable函数来完成的。以下是该函数的核心逻辑：




void
DropTable(DropStmt *stmt)
{
    DropTableInt(stmt, false);
}
 
static void
DropTableInt(DropStmt *stmt, bool concurrent)
{
    ...
    // 检查是否存在依赖关系，如果有则抛出错误
    checkDropRelStorage(relPersistence, nspname, stmt->arguments);
 
    // 如果表存在，则删除表和相关的对象（例如索引、默认值等）
    if (relPersistence == RELPERSISTENCE_TEMP)
        RemoveTempTable(nspname, stmt->arguments);
    else
        RemoveRelations(stmt);
    ...
}
 
static void
RemoveRelations(DropStmt *stmt)
{
    ...
    // 对于每个要删除的表，执行删除操作
    foreach(cell, stmt->objects)
    {
        DropObjectDetails *details = (DropObjectDetails *)lfirst(cell);
        RangeVar   *rel = details->object;
 
        // 查找并删除表
        removeObject(rel, stmt->behavior, stmt->missing_ok, stmt->concurrent);
        ...
    }
    ...
}
 
static void
removeObject(RangeVar *rel, DropBehavior behavior, bool missing_ok, bool concurrent)
{
    ...
    // 获取并锁定表的描述信息
    relId = RangeVarGetRelid(rel, AccessExclusiveLock, stmt->missing_ok);
    ...
    // 删除表和相关的数据字典项
    performDeletion(relId, behavior, rel->schemaname, concurrent);
    ...
}
 
static void
performDeletion(Oid objectId, DropBehavior behavior, const char *schemaName, bool concurrent)
{
    ...
    // 执行删除表的SQL命令
    object_access_hook_type = OBJECT_ACCESS_DELETE;
    PG_TRY();
    {
        heap_drop_with_catalog(relRelation, objectId, behavior);
        ...
    }
    ...
}

在上述代码中，DropTable函数首先会检查是否存在依赖关系，如果存在则抛出错误。接着，它会检查要删除的表是否存在，如果存在则删除表以及与其相关联的所有对象（如索引、默认值等）。最后，它会发送一个SQL命令到后端执行实际的删除操作。