Tech Blog

2024-09-02

MyBatis 是一个 Java 持久层框架，用于简化数据库的操作。

MyBatis 的使用：

配置 mybatis-config.xml 文件，定义数据库连接、事务管理和其他设置。
创建 Mapper 接口和 Mapper XML 文件，定义 SQL 映射规则。
通过 SqlSessionFactory 和 SqlSession 来执行 SQL 操作。

MyBatis 实现原理：

解析配置文件：MyBatis 启动时会解析 mybatis-config.xml 配置文件和 Mapper XML 文件。
构建 SQL 会话工厂：通过 SqlSessionFactory 创建 SqlSession。
执行 SQL：通过 SqlSession 执行 Mapper 接口中定义的方法，MyBatis 内部使用 Mapper 代理或反射来调用相应的 SQL。
结果映射：将 SQL 查询结果映射到 Java 对象。

MyBatis 优点：

简单易学易用，与 SQL 语句紧密配合，对性能要求高的系统有良好表现。
提供缓存机制，减少数据库负担。
可以手动编写 SQL，提供了高度的灵活性。

MyBatis 缺点：

需要编写 SQL 语句，不够简单易用，对开发人员要求较高。
不支持复杂的关系模型，可能需要自己编写复杂的 SQL 语句。
不支持自动更新和删除，需要手动编写 SQL 语句。

MyBatis 缓存：

一级缓存：SqlSession 级别的缓存，本次 SqlSession 内有效。
二级缓存：mapper 级别的缓存，跨 SqlSession，需要配置。

MyBatis 运行原理：

加载配置文件：配置来源于 XML 或注解。
解析配置：创建 Configuration 对象。
创建 SqlSessionFactory：通过 Configuration 对象。
创建 SqlSession：通过 SqlSessionFactory 创建。
创建 Mapper 接口的代理对象：使用 Mapper Proxy 机制。
执行操作：通过代理对象调用 SQL 方法。
处理输入参数：通过 ParameterHandler 处理输入参数。
查找缓存：Executor 通过 Cache 查找缓存。
执行 SQL：通过 Statement 执行 SQL。
处理输出结果：通过 ResultSetHandler 处理输出结果。
存储缓存：Executor 更新 Cache。
返回结果：将结果返回给调用者。

django 逆向生成对应数据库表的models模型类 —— python

2024-09-02

在Django中，可以使用inspectdb命令根据现有数据库表来生成对应的models.py中的模型类。以下是如何使用该命令的步骤：

确保你的数据库设置在settings.py文件中配置正确。
运行inspectdb命令来创建模型代码。

例如，如果你想要为名为myapp的应用生成模型，可以在终端中执行以下命令：




python manage.py inspectdb > myapp/models.py

这条命令会连接到数据库，检查所有表，并将生成的模型代码写入myapp/models.py文件中。如果你只想为特定的表生成模型，可以指定表名：




python manage.py inspectdb --database=default my_table_name > myapp/models.py

请注意，生成的模型代码可能需要进一步手动调整才能正确地使用在你的Django项目中，例如添加必要的字段属性、ForeignKey关联等。

Centos7源码编译安装PostgreSQL13.5版本数据库详细操作步骤

2024-09-02




#!/bin/bash
# 设置PostgreSQL的版本和安装路径
POSTGRESQL_VERSION="13.5"
POSTGRESQL_INSTALL_PATH="/opt/pgsql"
 
# 安装编译依赖
yum install -y readline-devel zlib-devel openssl-devel
 
# 创建PostgreSQL用户和组
groupadd postgres
useradd -g postgres postgres
 
# 创建安装目录并赋予权限
mkdir -p $POSTGRESQL_INSTALL_PATH
chown -R postgres:postgres $POSTGRESQL_INSTALL_PATH
 
# 以postgres用户登录
su - postgres
 
# 下载PostgreSQL源码
wget https://ftp.postgresql.org/pub/source/v$POSTGRESQL_VERSION/postgresql-$POSTGRESQL_VERSION.tar.gz
 
# 解压源码包
tar -zxvf postgresql-$POSTGRESQL_VERSION.tar.gz
 
# 进入解压后的目录
cd postgresql-$POSTGRESQL_VERSION
 
# 配置编译选项
./configure --prefix=$POSTGRESQL_INSTALL_PATH
 
# 编译安装
gmake
gmake install
 
# 创建PostgreSQL数据目录并赋予权限
mkdir $POSTGRESQL_INSTALL_PATH/data
chown -R postgres:postgres $POSTGRESQL_INSTALL_PATH/data
 
# 初始化数据库
$POSTGRESQL_INSTALL_PATH/bin/initdb -D $POSTGRESQL_INSTALL_PATH/data
 
# 启动PostgreSQL服务
$POSTGRESQL_INSTALL_PATH/bin/postgres -D $POSTGRESQL_INSTALL_PATH/data > /dev/null 2>&1 &
 
# 设置环境变量
echo "export PATH=$PATH:$POSTGRESQL_INSTALL_PATH/bin" >> ~/.bashrc
source ~/.bashrc
 
# 开机自启动
echo "$POSTGRESQL_INSTALL_PATH/bin/postgres -D $POSTGRESQL_INSTALL_PATH/data > /dev/null 2>&1 &" >> ~/.bashrc

这个脚本提供了在CentOS 7上从源码编译安装PostgreSQL 13.5的基本步骤。脚本首先安装了编译PostgreSQL所需的依赖，创建了postgres用户和组，并为PostgreSQL创建了安装目录。接下来，下载PostgreSQL源码，解压缩，配置编译选项，编译并安装PostgreSQL。最后，脚本创建了数据目录，初始化数据库，启动PostgreSQL服务，并将启动命令加入到用户的.bashrc文件中以便开机自启动。

mysql postgresql双数据源配置

2024-09-02

在Spring Boot应用中配置MySQL和PostgreSQL双数据源，你可以使用Spring Data JPA和Hibernate。以下是一个基本的配置示例：

在pom.xml中添加MySQL和PostgreSQL的依赖：




<!-- MySQL -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>Your MySQL version</version>
</dependency>
 
<!-- PostgreSQL -->
<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
    <version>Your PostgreSQL version</version>
</dependency>

配置application.properties或application.yml：




# MySQL
spring.datasource.mysql.url=jdbc:mysql://localhost:3306/your_mysql_db
spring.datasource.mysql.username=your_mysql_username
spring.datasource.mysql.password=your_mysql_password
 
# PostgreSQL
spring.datasource.pg.url=jdbc:postgresql://localhost:5432/your_pg_db
spring.datasource.pg.username=your_pg_username
spring.datasource.pg.password=your_pg_password

创建实体类和Repository接口，分别对应MySQL和PostgreSQL的数据模型。
配置双数据源：




@Configuration
public class DataSourceConfig {
 
    @Bean(name = "mysqlDataSource")
    @Primary
    @ConfigurationProperties(prefix = "spring.datasource.mysql")
    public DataSource mysqlDataSource() {
        return DataSourceBuilder.create().build();
    }
 
    @Bean(name = "pgDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.pg")
    public DataSource pgDataSource() {
        return DataSourceBuilder.create().build();
    }
}

配置JPA：




@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
        basePackages = "com.yourpackage.mysql.repository",
        entityManagerFactoryRef = "mysqlEntityManager",
        transactionManagerRef = "mysqlTransactionManager"
)
public class MySqlConfig {
 
    @Primary
    @Bean(name = "mysqlEntityManager")
    public LocalContainerEntityManagerFactoryBean mysqlEntityManager(
            EntityManagerFactoryBuilder builder,
            @Qualifier("mysqlDataSource") DataSource dataSource) {
        return builder
                .dataSource(dataSource)
                .packages("com.yourpackage.mysql.entity")
                .persistenceUnit("mysql")
                .build();
    }
 
    @Primary
    @Bean(name = "mysqlTransactionManager")
    public PlatformTransactionManager mysqlTransactionManager(
            @Qualifier("mysqlEntityManager") EntityManagerFactory entityManagerFactory) {
        return new JpaTransactionManage

运行Tomcat出现启动子级时出错

2024-09-02

报错："运行Tomcat时出现启动子级时错误"，这个错误信息比较模糊，没有提供具体的错误代码或者详细描述。不过，我可以给出一些常见的排查步骤和可能的解决方法。

查看错误日志：
检查Tomcat日志文件，通常位于Tomcat安装目录/logs下的catalina.out或catalina.YYYY-MM-DD.log文件。查找错误堆栈跟踪信息，以确定具体错误原因。
检查配置文件：
检查Tomcat安装目录/conf下的配置文件，如server.xml、web.xml、context.xml等，确保没有配置错误。
检查环境变量：
确保环境变量如JAVA_HOME正确设置，并指向了合适的JDK安装路径。
检查端口冲突：
确认Tomcat配置的端口没有被其他应用占用。默认端口是8080，可以通过netstat -ano | findstr 8080（Windows）或netstat -anp | grep 8080（Linux）来检查端口是否被占用。
检查权限问题：
确保Tomcat和它要访问的文件和目录有适当的文件系统权限。
关闭防火墙或者杀毒软件：
有时候防火墙或者杀毒软件可能会阻止Tomcat的启动。
重新安装Tomcat：
如果以上步骤都不能解决问题，尝试卸载Tomcat并重新安装。

如果错误信息更具体，可以提供更针对性的解决方案。

Oracle RAC 修改系统时区避坑指南（深挖篇）

2024-09-02




-- 假设我们需要将所有节点的时区更改为'Asia/Shanghai'
BEGIN
    FOR tz_rec IN (SELECT tzabbrev FROM v$timezone_abbrevs WHERE tzabbrev = 'CHINA')
    LOOP
        -- 在每个节点上设置时区环境变量
        EXECUTE IMMEDIATE 'ALTER SESSION SET TIME_ZONE = ''Asia/Shanghai''';
 
        -- 更新SPFILE以确保时区更改在重启后持久化
        EXECUTE IMMEDIATE 'ALTER SYSTEM SET TIME_ZONE = ''Asia/Shanghai'' SCOPE=SPFILE';
 
        -- 在所有节点上重新启动数据库服务
        FOR node_rec IN (SELECT node_name FROM v$cluster_database)
        LOOP
            -- 这里需要使用适当的节点级别的操作来重启服务，例如在Unix/Linux上使用srvctl
            EXECUTE IMMEDIATE 'srvctl stop database -db <your_db_name> -node ' || node_rec.node_name;
            EXECUTE IMMEDIATE 'srvctl start database -db <your_db_name> -node ' || node_rec.node_name;
        END LOOP;
 
        -- 确认时区已经更改
        SELECT CURRENT_TIMESTAMP FROM dual;
    END LOOP;
END;
/

这个代码示例展示了如何在Oracle RAC环境中更改时区。它首先检查时区是否已经是'Asia/Shanghai'，如果不是，则通过执行ALTER SESSION和ALTER SYSTEM命令来更改当前会话和SPFILE中的时区设置，并且通过srvctl命令重启所有节点上的数据库服务。最后，它提供了如何查询当前的时间戳来确认时区已经成功更改。这个过程是在PL/SQL块中执行的，并且对于每个节点都需要执行。

2024-09-02

在Windows环境下，可以通过编写一个批处理脚本来检测Tomcat服务是否运行，并在服务停止时自动重启。以下是一个简单的批处理脚本示例：




@echo off
set CATALINA_HOME=C:\path\to\your\tomcat
set SERVICE_NAME=Tomcat8
 
:checkService
sc query | findstr /I "%SERVICE_NAME%" >nul
if errorlevel 1 (
    echo Tomcat service is not running. Attempting to start service...
    call "%CATALINA_HOME%\bin\startup.bat"
    timeout /t 10 /nobreak
    goto checkService
) else (
    echo Tomcat service is running.
    timeout /t 10 /nobreak
    goto checkService
)

请将C:\path\to\your\tomcat替换为您的Tomcat安装路径，Tomcat8替换为您的Tomcat服务名称。

这个脚本会每10秒检查一次Tomcat服务是否运行。如果服务已停止，它会尝试启动Tomcat。这个过程会无限循环，除非你手动停止脚本。

将此脚本保存为.bat文件，并双击运行，或者将其添加到计划任务中以持续监控Tomcat服务。

Spring Cloud Gateway 修改请求体、响应体

2024-09-02

在Spring Cloud Gateway中，修改请求体和响应体可以通过自定义过滤器来实现。以下是一个简单的例子，展示如何创建一个自定义过滤器来修改请求体和响应体。

创建一个自定义的Gateway过滤器工厂：




import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.core.io.buffer.DataBufferFactory;
import org.springframework.core.io.buffer.DataBufferUtils;
import org.springframework.http.server.reactive.ServerHttpRequestDecorator;
import org.springframework.http.server.reactive.ServerHttpResponseDecorator;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
 
import java.nio.charset.StandardCharsets;
 
@Component
public class ModifyBodyGatewayFilterFactory extends AbstractGatewayFilterFactory<ModifyBodyGatewayFilterFactory.Config> {
    public ModifyBodyGatewayFilterFactory() {
        super(Config.class);
    }
 
    @Override
    public GatewayFilter apply(Config config) {
        return (exchange, chain) -> {
            // 修改请求体
            ServerHttpRequestDecorator decorator = new ServerHttpRequestDecorator(exchange.getRequest()) {
                @Override
                public Flux<DataBuffer> getBody() {
                    // 返回修改后的数据
                    return Flux.just(exchange.getResponse().bufferFactory().wrap(config.modifyRequestBody().getBytes()));
                }
            };
            exchange = exchange.mutate().request(decorator).build();
 
            // 修改响应体
            ServerHttpResponseDecorator responseDecorator = new ServerHttpResponseDecorator(exchange.getResponse()) {
                @Override
                public Mono<Void> writeWith(Flux<? extends DataBuffer> body) {
                    // 在这里可以对响应体进行修改，但是注意这里的body已经被读取了，如果需要读取和修改，需要使用cache()操作符
                    return super.writeWith(body.map(buffer -> {
                        byte[] content = new byte[buffer.readableByteCount()];
                        buffer.read(content);
                        // 修改响应内容
                        byte[] modifiedContent = config.modifyResponseBody(new String(content, StandardCharsets.UTF_8)).getBytes(StandardCharsets.UTF_8);
                        DataBuffer modifiedBuffer = exchange.getResponse().bufferFactory().wrap(modifiedContent

spring boot 启动流程详解

2024-09-02

Spring Boot 启动流程大致如下：

启动类：标有 @SpringBootApplication 注解的类是 Spring Boot 应用的入口。
@SpringBootApplication 注解是一个组合注解，包含了 @SpringBootConfiguration（继承自 @Configuration）、@EnableAutoConfiguration 和 @ComponentScan。
@EnableAutoConfiguration 开启自动配置功能，Spring Boot 基于 classpath 上的 jar 包依赖，对 Spring 应用进行自动配置。
run() 方法执行 Spring Application 的启动流程。
创建并配置当前环境的环境（Environment），包括 profiles 的激活、properties 的加载等。
创建并配置应用上下文（ApplicationContext），包括 beans 的加载和初始化。
启动完成后，执行应用的启动逻辑。

以下是一个简单的 Spring Boot 启动类示例：




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

在这个示例中，@SpringBootApplication 注解标注的 MyApp 类是 Spring Boot 应用的入口点。main 方法中调用了 SpringApplication.run() 方法，启动了 Spring Boot 应用。

高级DBA教你解决clickhouse数据库数据文件破坏磁盘碎片解决方法实战

2024-09-02




-- 假设我们有一个ClickHouse数据库表，其中包含一个名为'events'的表，我们需要优化它的数据分布
-- 首先，我们需要确定'events'表的分区键，假设我们按照日期分区
 
-- 第一步：重新分布分区数据
ALTER TABLE events MERGE PARTITION BY toYYYYMM(event_date);
 
-- 第二步：执行数据压缩，减少磁盘空间占用
OPTIMIZE TABLE events FINAL;
 
-- 第三步：重新加载损坏的分区，如果有的话
-- 首先，我们需要找出损坏的分区
SELECT partition, name, active FROM system.parts WHERE table = 'events' AND active = 0;
 
-- 假设我们找到了一个损坏的分区，例如 '202201'
-- 我们可以尝试重新加载这个分区
ALTER TABLE events DROP PARTITION 202201;
 
-- 然后，我们可以尝试从备份中恢复这个分区的数据，如果有的话
-- 如果没有备份，我们可以尝试重新插入数据来重建这个分区
INSERT INTO TABLE events (...) VALUES (...), (...), ..., (...);
 
-- 注意：具体的恢复和插入操作取决于数据的来源和结构。

这个实例代码展示了如何在ClickHouse中处理数据文件损坏和磁盘碎片问题。通过MERGE PARTITION BY来重新分布分区数据，OPTIMIZE TABLE来压缩数据，以及检测和修复损坏的分区。这些操作有助于提高数据库性能和数据的可靠性。