分类后端技术下的文章

Springboot项目：使用MockMvc测试get和post接口（含单个和多个请求参数场景）

2024-09-02




import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultHandlers;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
 
@SpringBootTest
@AutoConfigureMockMvc
public class MyControllerTest {
 
    @Autowired
    private MockMvc mockMvc;
 
    @Test
    void testGetRequest() throws Exception {
        mockMvc.perform(MockMvcRequestBuilders.get("/api/getData")
                .accept(MediaType.APPLICATION_JSON))
                .andExpect(MockMvcResultMatchers.status().isOk())
                .andDo(MockMvcResultHandlers.print());
    }
 
    @Test
    void testPostRequest() throws Exception {
        String requestBody = "{\"key1\":\"value1\",\"key2\":\"value2\"}";
        mockMvc.perform(MockMvcRequestBuilders.post("/api/postData")
                .contentType(MediaType.APPLICATION_JSON)
                .content(requestBody))
                .andExpect(MockMvcResultMatchers.status().isOk())
                .andDo(MockMvcResultHandlers.print());
    }
 
    @Test
    void testGetRequestWithQueryParam() throws Exception {
        String queryParam = "paramValue";
        mockMvc.perform(MockMvcRequestBuilders.get("/api/getDataWithQueryParam?queryParam=" + queryParam)
                .accept(MediaType.APPLICATION_JSON))
                .andExpect(MockMvcResultMatchers.status().isOk())
                .andDo(MockMvcResultHandlers.print());
    }
 
    @Test
    void testPostRequestWithFormData() throws Exception {
        String formData = "key1=value1&key2=value2";
        mockMvc.perform(MockMvcRequestBuilders.post("/api/postDataWithForm")
                .contentType(MediaType.APPLICATION_FORM_URLENCODED)
                .content(formData))
                .andExpect(MockMvcResultMatchers.status().isOk())
                .andDo(MockMvcResultHandlers.print());
    }
}

System

2024-09-02

所有,java




@Configuration
public class DataSourceConfig {
 
    @Bean
    @ConfigurationProperties("spring.datasource.primary")
    public DataSource primaryDataSource() {
        return DataSourceBuilder.create().build();
    }
 
    @Bean
    @ConfigurationProperties("spring.datasource.secondary")
    public DataSource secondaryDataSource() {
        return DataSourceBuilder.create().build();
    }
 
    @Bean
    public SqlSessionFactory sqlSessionFactory(DataSource primaryDataSource) throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(primaryDataSource);
        return sqlSessionFactoryBean.getObject();
    }
 
    @Bean
    public MybatisSqlSessionTemplate mybatisSqlSessionTemplate(
            @Qualifier("sqlSessionFactory") SqlSessionFactory sqlSessionFactory) {
        return new MybatisSqlSessionTemplate(sqlSessionFactory);
    }
 
    @Bean(name = "secondarySqlSessionFactory")
    public SqlSessionFactory secondarySqlSessionFactory(DataSource secondaryDataSource) throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(secondaryDataSource);
        return sqlSessionFactoryBean.getObject();
    }
 
    @Bean(name = "secondaryMybatisSqlSessionTemplate")
    public MybatisSqlSessionTemplate secondaryMybatisSqlSessionTemplate(
            @Qualifier("secondarySqlSessionFactory") SqlSessionFactory sqlSessionFactory) {
        return new MybatisSqlSessionTemplate(sqlSessionFactory);
    }
}

这个配置类定义了两个数据源primaryDataSource和secondaryDataSource，并为每个数据源创建了对应的SqlSessionFactory和MybatisSqlSessionTemplate。通过使用@Qualifier注解，你可以在需要的地方注入特定的SqlSessionFactory或SqlSessionTemplate。这样，你就可以根据业务需要选择使用哪一个数据源来执行数据库操作。

System

2024-09-02

所有,数据库

以下是搭建Oracle Data Guard的简化步骤，用于19c ADG环境的搭建：

准备主数据库服务器（Primary Database）：
- 安装Oracle 19c数据库。
- 创建备份目录。
- 配置监听器。
准备备用数据库服务器（Standby Database）：
- 安装Oracle 19c数据库。
- 创建备份目录。
- 配置监听器。

在主数据库上配置Oracle Data Guard环境：




-- 创建密码文件
orapwd file=orapwprimary password=your_password entries=5;
 
-- 配置主数据库的初始化参数
alter system set log_archive_config='DG_CONFIG=(primary,standby)' scope=both;
alter system set log_archive_dest_1='LOCATION=/u01/app/oracle/archive VALID_FOR=(ALL_LOGFILES,ALL_ROLES) DB_UNIQUE_NAME=primary' scope=both;
alter system set log_archive_dest_2='SERVICE=standby LGWR ASYNC VALID_FOR=(ONLINE_LOGFILES,PRIMARY_ROLE) DB_UNIQUE_NAME=standby' scope=both;
alter system set remote_login_passwordfile=exclusive scope=both;
alter system set db_unique_name='primary' scope=both;
alter system set log_archive_format='%t_%s_%r.arc' scope=both;
alter system set standby_file_management=auto scope=both;
alter database force logging;
 
-- 开启主数据库的Real Application Testest
alter system set fal_server='standby' scope=both;
alter system set fal_client='primary' scope=both;
alter system set standby_archive_dest='/u01/app/oracle/archive' scope=both;

在备用数据库上配置Oracle Data Guard环境：




-- 创建密码文件
orapwd file=orapwstandby password=your_password entries=5;
 
-- 配置备用数据库的初始化参数
alter system set log_archive_config='DG_CONFIG=(primary,standby)' scope=both;
alter system set log_archive_dest_1='LOCATION=/u01/app/oracle/archive VALID_FOR=(ALL_LOGFILES,ALL_ROLES) DB_UNIQUE_NAME=standby' scope=both;
alter system set log_archive_dest_2='SERVICE=primary LGWR ASYNC VALID_FOR=(ONLINE_LOGFILES,PRIMARY_ROLE) DB_UNIQUE_NAME=primary' scope=both;
alter system set remote_login_passwordfile=exclusive scope=both;
alter system set db_unique_name='standby' scope=both;
alter system set log_archive_format='%t_%s_%r.arc' scope=both;
alter system set standby_file_management=auto scope=both;
alter database force logging;
 
-- 开启备用数据库的Real Application Testest
alter system set fal_server='primary' scope=both;
alter system set fal_client='standby' scope=both;
alter system set standby_archive_dest='/u01/app/oracle/archive' scope=both;

在主数据库上配置TNS和Oracle Data Guard：




-- 编辑主数据库的tnsnames.ora文件
standby =
  (DESCRIPTION =
    (ADDRESS = (PROTOCOL = TCP

System

2024-09-02

所有,java

报错解释：

Nacos 启动时报 "Unable to start embedded Tomcat" 错误，意味着 Nacos 在尝试启动内嵌的 Tomcat 服务器时失败了。这可能是由于端口冲突、Tomcat 配置错误或者是 Nacos 配置文件中的问题。

解决方法：

检查端口冲突：确保 Nacos 配置的端口（默认为 8848）没有被其他应用占用。
检查 Tomcat 配置：如果有自定义 Tomcat 设置，请检查是否正确配置。
检查 Nacos 配置文件：检查 nacos 的配置文件（比如application.properties），确保所有配置项正确无误。
查看日志文件：检查 Nacos 的日志文件，通常在 Nacos 的 logs 目录下，查看具体的错误信息，以便进一步诊断问题。
检查系统环境：确保 Java 环境已正确安装且版本符合 Nacos 要求。
清理临时文件：有时候，清理 Nacos 的临时文件（比如临时目录下的文件）可以解决问题。

如果上述步骤无法解决问题，可以尝试重新下载或更新 Nacos 的安装包，或者查看官方文档和社区支持寻求帮助。

- 阅读更多 -

探索Spring Boot与Kafka的完美融合：实战配置指南

System

2024-09-02

所有,java




import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.serialization.StringSerializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.core.ProducerFactory;
import org.springframework.kafka.core.DefaultKafkaProducerFactory;
import java.util.HashMap;
import java.util.Map;
 
@Configuration
public class KafkaProducerConfig {
 
    @Bean
    public ProducerFactory<String, String> producerFactory() {
        Map<String, Object> props = new HashMap<>();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        // 这里可以添加更多的配置属性
        return new DefaultKafkaProducerFactory<>(props);
    }
}

这段代码定义了一个配置类KafkaProducerConfig，其中包含了一个Bean方法producerFactory，用于创建一个ProducerFactory实例。这个实例用于配置和创建Kafka生产者，以便在Spring Boot应用程序中发送消息到Kafka broker。在这个例子中，我们配置了生产者去连接本地的Kafka服务，并且指定了使用StringSerializer来序列化键和值。这个配置可以根据实际的Kafka服务器地址和序列化需求进行调整。

- 阅读更多 -

Centos7下安装PostgreSQL15

System

2024-09-02

所有,数据库

在CentOS 7上安装PostgreSQL 15，你可以按照以下步骤操作：

添加PostgreSQL的官方仓库：




sudo yum install -y https://download.postgresql.org/pub/repos/yum/reporpms/EL-7-x86_64/pgdg-redhat-repo-latest.noarch.rpm

清除缓存：




sudo yum clean all

安装PostgreSQL 15：




sudo yum install -y postgresql15 postgresql15-server

初始化数据库：




sudo /usr/pgsql-15/bin/postgresql-15-setup initdb

启动PostgreSQL服务：




sudo systemctl enable postgresql-15
sudo systemctl start postgresql-15

确认PostgreSQL服务状态：




sudo systemctl status postgresql-15

登录到PostgreSQL数据库：




sudo -i -u postgres
psql -d postgres

以上步骤将安装PostgreSQL 15并进行基本设置。确保在执行每个步骤之前，你都有适当的权限，并且系统是最新的。

- 阅读更多 -

Centos 配置JDK和Tomcat（新手版）

System

2024-09-02

所有,java

在CentOS上配置JDK和Tomcat的步骤如下：

安装Java JDK




sudo yum update
sudo yum install java-1.8.0-openjdk-devel

验证安装




java -version

设置JAVA\_HOME环境变量




echo 'export JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk' | sudo tee -a ~/.bashrc
echo 'export PATH=JAVAHOME/bin:PATH' | sudo tee -a ~/.bashrc
source ~/.bashrc

安装Tomcat




sudo yum install tomcat tomcat-webapps tomcat-admin-webapps

启动Tomcat服务




sudo systemctl start tomcat

验证Tomcat安装
打开浏览器并输入服务器的IP地址或域名后跟":8080"，例如http://your_server_ip:8080，你应该看到Tomcat的默认页面。

以上步骤提供了一个基本的JDK和Tomcat安装过程，确保按照系统提示进行操作，并根据需要调整版本号和安装路径。

- 阅读更多 -

SpringBoot动态定时任务(完整版)

System

2024-09-02

所有,java

在Spring Boot中创建动态定时任务，可以使用ThreadPoolTaskScheduler来实现。以下是一个简化版的示例代码：




import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.scheduling.config.CronTask;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.support.CronExpression;
 
import java.util.concurrent.ConcurrentHashMap;
 
@Configuration
public class DynamicScheduleConfig {
 
    private final ThreadPoolTaskScheduler taskScheduler;
    private final ConcurrentHashMap<String, Runnable> tasksMap;
 
    public DynamicScheduleConfig(ThreadPoolTaskScheduler taskScheduler) {
        this.taskScheduler = taskScheduler;
        this.tasksMap = new ConcurrentHashMap<>();
    }
 
    @Bean
    public ThreadPoolTaskScheduler taskScheduler() {
        return new ThreadPoolTaskScheduler();
    }
 
    public void addTask(String taskId, Runnable task, String cronExpression) {
        CronTask cronTask = new CronTask(task, CronExpression.parse(cronExpression));
        tasksMap.put(taskId, task);
        taskScheduler.schedule(cronTask.getRunnable(), cronTask.getTrigger());
    }
 
    public void removeTask(String taskId) {
        Runnable task = tasksMap.remove(taskId);
        if (task != null) {
            taskScheduler.getScheduledFutures().forEach(future -> {
                if (future.getTask() == task) {
                    future.cancel(true);
                }
            });
        }
    }
 
    @Bean
    public ScheduledTaskRegistrar scheduledTaskRegistrar() {
        ScheduledTaskRegistrar taskRegistrar = new ScheduledTaskRegistrar();
        taskRegistrar.setTaskScheduler(taskScheduler);
        return taskRegistrar;
    }
}

使用方法：

调用addTask方法添加任务，需要提供任务ID、任务内容和cron表达式。
调用removeTask方法移除任务，只需要提供任务ID。

这个配置类中定义了一个ThreadPoolTaskScheduler，用于执行定时任务。同时，使用了一个ConcurrentHashMap来存储动态添加的任务，以便后续可以移除它们。

注意：

这个示例没有处理并发添加或删除任务可能引发的并发问题。在实际应用中，可能需要添加适当的同步机制。
任务的ID应该是唯一的，以便正确地移除特定的任务。
这个示例没有包含任务的逻辑，你需要根据实际需求实现Runnable任务。

- 阅读更多 -

金仓数据库KingbaseES 函数与存储过程内容加密

System

2024-09-02

所有,数据库

在金仓数据库（KingbaseES）中，要对函数与存储过程的内容进行加密，可以使用数据库提供的加密功能。以下是一个简单的例子，展示如何创建加密的函数：




-- 创建加密函数
CREATE OR REPLACE FUNCTION encrypt_text(plaintext TEXT) RETURNS TEXT AS $$
BEGIN
    -- 这里使用了KingbaseES的内置加密函数，具体函数名称可能需要根据实际情况调整
    RETURN kb_encrypt('aes', plaintext, 'your-encryption-key');
END;
$$ LANGUAGE plpgsql STRICT;
 
-- 创建加密存储过程
CREATE OR REPLACE PROCEDURE secure_procedure() AS $$
BEGIN
    -- 这里可以执行加密的业务逻辑
    RAISE NOTICE 'Procedure is executing securely with encrypted content.';
END;
$$ LANGUAGE plpgsql SECURITY DEFINER;

在这个例子中，encrypt_text 函数接收一个普通文本作为参数，并使用 kb_encrypt 函数（假设的加密函数，需要替换为KingbaseES支持的实际加密函数）进行加密。secure_procedure 存储过程作为一个加密的例子，在其内部可以执行加密的业务逻辑。

请注意，实际使用时需要替换 'aes' 和 'your-encryption-key' 为实际的加密算法和密钥，并确保数据库用户有权限使用加密函数。

由于具体的加密函数和方法可能依赖于KingbaseES的版本和配置，请参考相应的KingbaseES文档来获取准确的函数名称和用法。

- 阅读更多 -

Redis的持久化详解

System

2024-09-02

所有,redis

Redis的持久化主要有两种方式：RDB（Redis DataBase）和AOF（Append Only File）。

RDB：定时将内存中的数据快照保存到磁盘的一个压缩二进制文件中。可以配置定时任务来控制快照的频率。




# 配置保存点（在redis.conf中设置）
save 900 1      # 900秒内至少1个键被修改则保存
save 300 10     # 300秒内至少10个键被修改则保存
save 60 10000   # 60秒内至少10000个键被修改则保存

AOF：每个写命令都通过append操作保存到文件中。在服务重启时，通过重放这些命令来恢复数据。




# 配置AOF持久化（在redis.conf中设置）
appendonly yes       # 开启AOF持久化
appendfilename "appendonly.aof"  # AOF文件名
# appendfsync always   # 每个命令都同步，最慢但最安全
# appendfsync everysec # 每秒同步一次，折衷方案
# appendfsync no       # 由操作系统决定何时同步

在实际应用中，可以两者结合使用，或者只使用其中一种。根据需求和性能考量，选择合适的持久化策略。

- 阅读更多 -