Tech Blog

2024-09-02

所有,java

要在一台计算机上运行两个Tomcat服务，您需要进行以下步骤：

安装两个版本的Tomcat到不同的文件夹。
修改两个Tomcat实例的配置文件以使用不同的端口号。

以下是修改配置的关键步骤：

对于Tomcat 7 或更高版本：

打开<Tomcat-home-1>/conf/server.xml和<Tomcat-home-2>/conf/server.xml。
找到<Connector port="8080" ... />元素。
将第一个实例的端口号改为例如8080，第二个实例改为例如8081。
对于<Connector port="8009" ... />（AJP端口）也进行相应更改，确保不冲突。

对于Tomcat 6 或更低版本：

编辑<Tomcat-home-1>/conf/server.xml和<Tomcat-home-2>/conf/server.xml中的<Connector>元素。
更改minProcessors、maxProcessors、port和redirectPort属性。

示例代码：

Tomcat 7 或更高版本的配置更改：




<!-- Tomcat 1 -->
<Connector port="8080" protocol="HTTP/1.1"
           connectionTimeout="20000"
           redirectPort="8443" />
<!-- Tomcat 2 -->
<Connector port="8081" protocol="HTTP/1.1"
           connectionTimeout="20000"
           redirectPort="8444" />

启动两个Tomcat实例：

在第一个实例中，进入<Tomcat-home-1>/bin目录，并运行./startup.sh（在Unix/Linux系统中）或startup.bat（在Windows系统中）。
对第二个实例重复相同的步骤，确保使用第二个Tomcat实例的路径和端口配置。

确保两个实例使用的是不同的端口号，以防止HTTP和AJP端口冲突。此外，确保防火墙或网络设置允许访问这些端口。

Redis常见面试问题汇总梳理解答

2024-09-02

所有,redis

Redis是一种开源的内存中数据结构存储系统，可以用作数据库、缓存和消息中间件。以下是一些常见的Redis面试问题及其解答：

Redis的数据类型？
Redis支持五种数据类型：字符串(String), 列表(List), 集合(Set), 有序集合(Sorted Set)和哈希(Hash)。
使用Redis有哪些好处？
1. 速度快，数据存储在内存中，能够提供高速的读写能力。
2. 数据结构服务，提供字符串、哈希、列表、集合等多种数据结构的存储。
3. 持久化选项，可以将数据保存到硬盘，以防止数据丢失。
4. 支持发布/订阅模式，可以用作消息队列。
Redis的持久化方式？
1. RDB：定时将内存中的数据快照保存到磁盘。
2. AOF：保存Redis服务器所执行的所有写操作命令到文件。
Redis的过期时间和淘汰策略？
过期时间：可以使用EXPIRE命令设置键的生存时间。
淘汰策略：
- 定时淘汰：每个设置了过期时间的键都有一个定时器，到时间就自动删除。
- 惰性删除：当访问一个键时，才会检查是否过期，过期则删除。
- 定期删除：每隔一段时间，随机抽查一些键，删除其中已经过期的键。
Redis的事务？
Redis的事务可以一起执行多个命令，它可以保证一系列命令在执行时不会被其他操作打断。
Redis的分布式锁？
可以使用SETNX命令实现分布式锁，当键不存在时，才能成功设置键值，否则失败。
Redis的LRU淘汰策略？
Redis可以使用maxmemory-policy配置来设置LRU（最近最少使用）策略，当内存不足时，会根据这个策略来淘汰某些键。
Redis的性能问题和调优？
1. 使用批量操作减少网络时延。
2. 使用管道（pipeline）技术减少客户端和服务器之间的往返时延。
3. 根据实际需求调整数据结构和持久化策略。
4. 使用Redis的内存淘汰机制。
Redis的集群方式？
1. 主从复制：将数据复制到其他Redis服务器。
2. Redis Cluster：使用分片来存储数据。
如何解决Redis缓存穿透和缓存雪崩问题？
缓存穿透：可以使用布隆过滤器（Bloom Filter）来检查请求是否有效。
缓存雪崩：可以通过设置热点数据的永不过期，或者使用互斥锁来保证同时只有一个客户端去数据库加载数据。

这些是关于Redis常见的面试问题，每个问题都可以展开讨论很多，以上答案是为了给出一个概览而不是详尽的解答。

2024-09-02




-- 假设在PostgreSQL中，流复制已经配置并运行正常，现在需要处理备库上的锁冲突或Vacuum冲突。
 
-- 解决备库上的锁冲突：
 
-- 步骤1: 查看当前的锁等待信息
SELECT pid, mode, granted, query FROM pg_locks JOIN pg_stat_activity ON pg_locks.pid = pg_stat_activity.pid WHERE NOT granted;
 
-- 步骤2: 如果发现长时间持有锁的查询，可以尝试终止这些查询
SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE pid <> pg_backend_pid() AND state = 'active' AND query ILIKE '%长时间运行的锁冲突查询%';
 
-- 解决备库上的Vacuum冲突：
 
-- 步骤1: 查看当前的Vacuum进度
SELECT pid, datname, state, query FROM pg_stat_activity WHERE query ILIKE '%vacuum%';
 
-- 步骤2: 如果Vacuum进程被阻塞，可以考虑重新调度Vacuum操作或优化Vacuum参数
-- 可以通过设置vacuum_cost_delay来调整VACUUM的行为，减少VACUUM操作对主库性能的影响
 
-- 解决方法示例：
-- 1. 通过pg_stat_activity查看当前锁等待信息和Vacuum状态。
-- 2. 如果Vacuum进程长时间处于autovacuum_freeze_max_age之类的清理动作，考虑调整相关参数，如autovacuum_vacuum_scale_factor和autovacuum_vacuum_threshold。
-- 3. 如果因为长时间的锁等待导致Vacuum无法进行，尝试终止长时间占用锁的查询。
-- 4. 如果需要，可以手动运行VACUUM操作，但要注意不要和正在进行的Vacuum冲突。

这段代码提供了解决PostgreSQL备库上的锁冲突和Vacuum冲突的基本步骤。开发者和数据库管理员可以根据实际情况调整参数和策略。

使用C++对SQLite3数据库进行增、删、改、查操作实例

2024-09-02




#include <iostream>
#include <sqlite3.h>
 
// 定义数据库操作的宏
#define DB_PATH "example.db"
#define SQL_CREATE "CREATE TABLE IF NOT EXISTS user (id INTEGER PRIMARY KEY, name TEXT, age INTEGER, email TEXT)"
#define SQL_INSERT "INSERT INTO user (name, age, email) VALUES (?, ?, ?)"
#define SQL_DELETE "DELETE FROM user WHERE id = ?"
#define SQL_UPDATE "UPDATE user SET name = ?, age = ?, email = ? WHERE id = ?"
#define SQL_SELECT "SELECT id, name, age, email FROM user WHERE id = ?"
 
// 创建数据库表
int createTable(sqlite3* db) {
    char* errMsg = nullptr;
    if (sqlite3_exec(db, SQL_CREATE, nullptr, nullptr, &errMsg) != SQLITE_OK) {
        std::cerr << "创建表失败: " << errMsg << std::endl;
        sqlite3_free(errMsg);
        return -1;
    }
    return 0;
}
 
// 插入数据
int insertData(sqlite3* db, int id, const std::string& name, int age, const std::string& email) {
    sqlite3_stmt* stmt;
    if (sqlite3_prepare_v2(db, SQL_INSERT, -1, &stmt, nullptr) == SQLITE_OK) {
        sqlite3_bind_text(stmt, 1, name.c_str(), -1, SQLITE_TRANSIENT);
        sqlite3_bind_int(stmt, 2, age);
        sqlite3_bind_text(stmt, 3, email.c_str(), -1, SQLITE_TRANSIENT);
 
        if (sqlite3_step(stmt) != SQLITE_DONE) {
            std::cerr << "插入数据失败: " << sqlite3_errmsg(db) << std::endl;
            sqlite3_finalize(stmt);
            return -1;
        }
        sqlite3_finalize(stmt);
    } else {
        std::cerr << "准备插入语句失败: " << sqlite3_errmsg(db) << std::endl;
        return -1;
    }
    return 0;
}
 
// 删除数据
int deleteData(sqlite3* db, int id) {
    sqlite3_stmt* stmt;
    if (sqlite3_prepare_v2(db, SQL_DELETE, -1, &stmt, nullptr) == SQLITE_OK) {
        sqlite3_bind_int(stmt, 1, id);
 
        if (sqlite3_step(stmt) != SQLITE_DONE) {
            std::cerr << "删除数据失败: " << sqlite3_errmsg(db) << std::endl;
            sqlite3_finalize(stmt);
            return -1;
        }
        sqlite3_finalize(stmt);
    } else {
        std::cerr << "准备删除语句失败: " << sqlite3_errmsg(db) << std::endl;
        return -1;
    }

ORA-28000: the account is locked 解决办法

2024-09-02

解释：

ORA-28000错误表示Oracle数据库中的用户账号被锁定。用户账号被锁定通常是因为多次输入错误的密码，数据库管理员为了安全起见会锁定账号一段时间。

解决办法：

作为数据库管理员，你可以登录到数据库并解锁用户账号。使用以下SQL命令：




ALTER USER username ACCOUNT UNLOCK;

将username替换为实际的用户账号名称。

如果你不是数据库管理员，你需要联系数据库管理员请求解锁账号。
确保用户在未来不会因为密码错误而被锁定，可以修改用户的profile来调整密码错误次数的限制，或者使密码过期时间更长。

例如，设置密码永不过期可以使用：




ALTER PROFILE DEFAULT LIMIT PASSWORD_LIFE_TIME UNLIMITED;

或者调整错误次数限制：




ALTER PROFILE DEFAULT LIMIT FAILED_LOGIN_ATTEMPTS UNLIMITED;

请注意，修改默认profile会影响所有用户，确保这是你想要的行为。

Mybatis使用注解实现复杂动态SQL

2024-09-02

所有,java

在MyBatis中，使用注解可以实现复杂的动态SQL。以下是一个使用@SelectProvider注解来实现复杂动态SQL的例子：

首先，创建一个SQL提供类：




public class ComplexSqlProvider {
    public String buildComplexSql(Map<String, Object> parameters) {
        // 构建动态SQL语句
        String sql = "SELECT * FROM users";
        if (parameters.get("age") != null) {
            sql += " WHERE age > #{age}";
        }
        if (parameters.get("name") != null) {
            sql += " AND name LIKE #{name}";
        }
        return sql;
    }
}

然后，在Mapper接口中使用@SelectProvider注解来指定这个SQL提供类：




public interface UserMapper {
    @SelectProvider(type = ComplexSqlProvider.class, method = "buildComplexSql")
    List<User> findUsersByDynamicSql(Map<String, Object> parameters);
}

最后，你可以这样调用Mapper方法，传入不同的参数来执行不同的查询：




Map<String, Object> params = new HashMap<>();
params.put("age", 18);
params.put("name", "%John%");
 
List<User> users = userMapper.findUsersByDynamicSql(params);

这个例子展示了如何根据传入的参数动态构建并执行SQL查询。通过这种方式，你可以根据实际需求灵活地生成复杂的SQL语句。

ORACLE UNION ALL查询报错ORA-12704: 字符集不匹配

2024-09-02

错误解释：

ORA-12704 错误表示在执行 UNION ALL 操作时，涉及的两个查询结果集中的列使用了不同的字符集。Oracle 不允许在 UNION ALL 操作中合并具有不同字符集的列。

解决方法：

确认两个查询中的相关列都使用相同的字符集。可以通过查询数据字典视图 ALL_TAB_COLUMNS 或 USER_TAB_COLUMNS 来查看这些列的字符集。
如果列的字符集不同，需要修改查询，确保 UNION ALL 操作涉及的所有列都使用相同的字符集。
如果修改查询不可行，可以考虑使用数据库转换函数 TO_CHAR, TO_NCHAR, CAST 等，将字符集不匹配的列转换为相同的字符集。
确保数据库实例的字符集设置能够兼容两个查询中涉及的字符集。

示例修改查询（以 TO_CHAR 为例）：




SELECT TO_CHAR(column_name_1) AS column_name_1, column_name_2
FROM table_1
UNION ALL
SELECT TO_CHAR(column_name_1) AS column_name_1, column_name_2
FROM table_2;

在这个示例中，我们使用 TO_CHAR 函数将两个查询中的 column_name_1 列转换为相同的字符集，这样就可以在 UNION ALL 操作中使用了。

Oracle中获取汉字拼音码

2024-09-02

在Oracle数据库中，获取汉字拼音码通常需要使用一些特定的函数或者存储过程，因为Oracle自身并没有内置这样的功能。不过，你可以使用第三方的PL/SQL库或者编写自定义的函数来实现这个需求。

以下是一个简单的例子，演示如何使用自定义的PL/SQL函数来实现这个功能：




CREATE OR REPLACE FUNCTION get_pinyin (
    chinese VARCHAR2
) RETURN VARCHAR2 IS
    pinyin VARCHAR2(4000);
BEGIN
    -- 这里应该是你自定义的逻辑，将汉字转换为拼音
    -- 示例中仅将每个汉字替换为其大写形式
    FOR i IN 1..LENGTH(chinese) LOOP
        pinyin := pinyin || UPPER(SUBSTR(chinese, i, 1));
    END LOOP;
 
    RETURN pinyin;
END;
/
 
-- 使用函数的例子
SELECT get_pinyin('你好世界') FROM dual;

请注意，这个函数只是一个简单的示例，它不会真正地转换汉字到拼音。在实际应用中，你需要一个能够处理汉字拼音转换逻辑的复杂函数，这可能需要借助外部库或者有经验的开发者编写相应的逻辑。

如果你需要一个更复杂的解决方案，可以考虑使用第三方提供的PL/SQL库，如NLS_PINYIN，或者在应用层处理拼音码的转换。

2024-09-02

在PostgreSQL中，如果你在PL/pgSQL的事务块中遇到了这样的问题，即在一个嵌套的事务块中，外层事务块设置了SAVEPOINT，并且在内层事务块中使用了EXCEPTION来处理异常，并且在内层事务块中也有ROLLBACK操作，那么可能会遇到一个问题，即内层的ROLLBACK可能会影响到外层事务块的状态。

这是因为在PostgreSQL中，一旦你执行了ROLLBACK，它会回滚到最近的SAVEPOINT，而不仅仅是内层事务块的SAVEPOINT。这就导致了所谓的“不支持事务块中调用plpgsql回滚”的问题。

解决方案：

使用PL/pgSQL中的EXCEPTION来捕获内层事务块中的异常，并在内层事务块结束后再做ROLLBACK操作。
使用PL/pgSQL中的控制结构，如LOOP或者BEGIN ... END来代替事务块的嵌套。
使用PL/pgSQL中的动态SQL，在EXECUTE命令中写入ROLLBACK，并在内层事务块中捕获SQLSTATE异常。

示例代码：




DO $$
DECLARE
    outer_savepoint_name TEXT := 'outer_savepoint';
    inner_savepoint_name TEXT := 'inner_savepoint';
BEGIN
    -- 设置外层SAVEPOINT
    SAVEPOINT outer_savepoint_name;
 
    -- 内层事务块
    BEGIN
        -- 设置内层SAVEPOINT
        SAVEPOINT inner_savepoint_name;
 
        -- 这里是可能会抛出异常的代码
        -- ...
 
        -- 如果没有异常发生，则正常COMMIT
        -- COMMIT;
    EXCEPTION
        WHEN OTHERS THEN
            -- 处理异常
            RAISE NOTICE 'Caught an exception: %', SQLERRM;
 
            -- 如果发生异常，则内层ROLLBACK
            ROLLBACK TO inner_savepoint_name;
    END;
 
    -- 外层事务块结束，如果需要的话，可以再做一次COMMIT
    -- COMMIT;
EXCEPTION
    WHEN OTHERS THEN
        -- 处理外层事务块中的异常
        RAISE NOTICE 'Caught an exception in outer block: %', SQLERRM;
 
        -- 如果发生异常，则外层ROLLBACK
        ROLLBACK TO outer_savepoint_name;
END $$;

在这个示例中，我们首先设置了一个外层的SAVEPOINT，然后开始了一个内层的事务块。在内层事务块中，我们捕获所有的异常，并在异常处理代码中执行ROLLBACK TO inner\_savepoint\_name，这样只会回滚到内层的SAVEPOINT，而不会影响到外层的SAVEPOINT。最后，在外层事务块中捕获任何可能发生的异常，并执行相应的ROLLBACK。这样就可以在嵌套事务中正确地使用ROLLBACK，而不会影响到外层的事务。

SpringBoot源码阅读(10)——后处理器

2024-09-02

所有,java

在SpringBoot中，后处理器用于在容器启动完成后，对某些组件进行自定义的处理。这些组件可能是应用上下文中的Bean，或者是特定的事件。

SpringBoot提供了ApplicationContextInitializer，BeanFactoryPostProcessor，ApplicationListener等接口，用于在容器启动过程中进行扩展和自定义。

以下是一个使用ApplicationContextInitializer的示例：




import org.springframework.context.ApplicationContextInitializer;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.core.env.ConfigurableEnvironment;
 
public class MyApplicationContextInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        ConfigurableEnvironment environment = applicationContext.getEnvironment();
        // 可以在这里对环境进行自定义配置
        environment.getSystemProperties().put("property.name", "property.value");
    }
}

在application.properties或application.yml中启用这个ApplicationContextInitializer：




spring.context.initializer.classes=com.example.MyApplicationContextInitializer

以上代码在SpringBoot应用上下文初始化时，会向系统属性中添加一个自定义的配置项。

另外，可以通过实现BeanFactoryPostProcessor接口来自定义Bean的创建过程：




import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
 
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        // 可以在这里自定义Bean的创建过程
        // 例如修改Bean的定义，增加属性等
    }
}

在SpringBoot应用中注册这个BeanFactoryPostProcessor：




import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
@Configuration
public class MyConfiguration {
    @Bean
    public BeanFactoryPostProcessor beanFactoryPostProcessor() {
        return new MyBeanFactoryPostProcessor();
    }
}

最后，可以通过实现ApplicationListener接口来监听并响应SpringBoot中的特定事件：




import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;
 
public class MyApplicationListener implements ApplicationListener<App