分类后端技术下的文章

2024-09-06

在Oracle 19c中搭建单实例ADG（Automatic Data Guard）的过程大致如下：

准备主数据库（Primary Database）和备份数据库（Standby Database）的环境。
创建主数据库。
配置主数据库的参数。
设置主数据库的归档模式。
创建备份数据库。
配置备份数据库的参数。
设置备份数据库的归档模式。
配置主备数据库之间的Data Guard。
验证Data Guard配置。

以下是一个简化的示例流程：




-- 步骤1: 创建主数据库
CREATE DATABASE primary_db
   CONTROLFILE REUSE
   LOGFILE
     GROUP 1 ('/u01/oradata/primary/redo01.log') SIZE 100M,
     GROUP 2 ('/u01/oradata/primary/redo02.log') SIZE 100M
   DATAFILE
     '/u01/oradata/primary/system01.dbf' SIZE 500M AUTOEXTEND ON NEXT 10M MAXSIZE UNLIMITED
   SYSAUX DATAFILE
     '/u01/oradata/primary/sysaux01.dbf' SIZE 500M AUTOEXTEND ON NEXT 10M MAXSIZE UNLIMITED
   SMALLFILE
     '/u01/oradata/primary/users01.dbf' SIZE 200M REUSE
     AUTOEXTEND ON NEXT 10M MAXSIZE UNLIMITED
   CHARACTER SET AL32UTF8
   NATIONAL CHARACTER SET AL16UTF16
   EXTENT MANAGEMENT LOCAL;
 
-- 步骤2: 修改主数据库的初始化参数 (init.ora)
-- 例如:
db_unique_name = primary_db
log_archive_config = DG_CONFIG=(primary_db,standby_db)
log_archive_dest_1 = LOCATION=/u01/archivelog VALID_FOR=(ALL_LOGFILES,ALL_ROLES)
log_archive_dest_2 = SERVICE=standby_db LGWR ASYNC VALID_FOR=(ONLINE_LOGFILES,PRIMARY_ROLE)
 
-- 步骤3: 启用归档模式
ALTER SYSTEM ARCHIVE LOG;
 
-- 步骤4: 创建备份数据库 (使用主数据库的备份)
RMAN> RESTORE DATABASE;
RMAN> RECOVER DATABASE;
RMAN> ALTER DATABASE MOUNT;
RMAN> ALTER DATABASE OPEN RESETLOGS;
 
-- 步骤5: 修改备份数据库的初始化参数 (init.ora)
-- 例如:
db_unique_name = standby_db
log_archive_config = DG_CONFIG=(primary_db,standby_db)
log_archive_dest_1 = LOCATION=/u01/archivelog VALID_FOR=(ALL_LOGFILES,ALL_ROLES)
log_archive_dest_2 = SERVICE=primary_db LGWR ASYNC VALID_FOR=(ONLINE_LOGFILES,PRIMARY_ROLE)
 
-- 步骤6: 启用归档模式
ALTER SYSTEM ARCHIVE LOG;
 
-- 步骤7: 配置主备数据库之间的Data Guard
-- 使用Data Guard Broker或手动配置
-- 例如:
ALTER SYSTEM SET log_archive_dest_state_1=ENABLE SCOPE=BOTH;
ALTER SYSTEM SET log_archive_dest_state_2=ENABLE SCOPE=BOTH;
 
-- 步骤8: 验证配置
-- 查看日志传送状态
SELECT dest_id, status, type, destination FROM v$archive_dest;
 
-- 查看Data

- 阅读更多 -

# Redis 入门到精通-- redis 持久化

System

2024-09-06

所有,redis




#include "hdr_hdlr.h"
#include "latency_hdr_hdlr.h�"
#include "valgrind_hdr_hdlr.h"
 
// 测试 RDB 快照持久化
int test_rdb_snapshot_persistence(struct test_context *ctx) {
    redisAsyncContext *c = &ctx->c;
    redisAsyncCommand(c, %(cb)s, "%(test_id)s", "SET key1 value1");
    redisAsyncCommand(c, %(cb)s, "%(test_id)s", "SET key2 value2");
    redisAsyncCommand(c, %(cb)s, "%(test_id)s", "SET key3 value3");
    // ... 等待回调执行
    return 0;
}
 
// 测试 AOF 持久化
int test_aof_persistence(struct test_context *ctx) {
    redisAsyncContext *c = &ctx->c;
    redisAsyncCommand(c, %(cb)s, "%(test_id)s", "SET key4 value4");
    redisAsyncCommand(c, %(cb)s, "%(test_id)s", "SET key5 value5");
    redisAsyncCommand(c, %(cb)s, "%(test_id)s", "SET key6 value6");
    // ... 等待回调执行
    return 0;
}
 
// 测试 RDB 和 AOF 同时开启
int test_rdb_and_aof_together(struct test_context *ctx) {
    redisAsyncContext *c = &ctx->c;
    redisAsyncCommand(c, %(cb)s, "%(test_id)s", "SET key7 value7");
    redisAsyncCommand(c, %(cb)s, "%(test_id)s", "SET key8 value8");
    redisAsyncCommand(c, %(cb)s, "%(test_id)s", "SET key9 value9");
    // ... 等待回调执行
    return 0;
}
 
// 测试 RDB 快照文件的一致性
int test_rdb_consistency(struct test_context *ctx) {
    // ... 验证 RDB 文件的一致性
    return 0;
}
 
// 测试 AOF 文件的一致性
int test_aof_consistency(struct test_context *ctx) {
    // ... 验证 AOF 文件的一致性
    return 0;
}
 
// 测试 RDB 和 AOF 同时开启的一致性
int test_rdb_and_aof_together_consistency(struct test_context *ctx) {
    // ... 验证 RDB 和 AOF 同时开启的一致性
    return 0;
}
 
// 测试 RDB 快照文件的持久性
int test_rdb_persistence_during_redis_stop(struct test_context *ctx) {
    // ... 停止 Redis 服务，并验证 RDB 文件的持久性
    return 0;
}
 
// 测试 AOF 文件的持久性
int test_aof_persistence_during_redis_stop(struct test_context *ctx) {
    // ... 停止 Redis 服务，并验证 AOF 文件的持久性
    return 0;
}
 
// 测试 RDB 和 AOF 同时开启的持久性
int test_rdb_and_aof_together_persistence_during_redis_stop(struct test_context *ctx) {
    // ... 停止 Redis 服务，并验证 RDB 和 AOF 同时开启的持久性
    return 0;
}
 
// 测试 RDB 快照文件的安全性
int test_rdb_safety(struct test_context *ctx) {
    // ... 测试 Redis 在崩溃时 RDB 文件的安全性
    return 0;

- 阅读更多 -

Spring Cloud Sentinel整合Nacos实现配置持久化

System

2024-09-06

所有,java




import com.alibaba.csp.sentinel.datasource.ReadableDataSource;
import com.alibaba.csp.sentinel.datasource.nacos.NacosDataSource;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
import com.alibaba.fastjson.JSON;
import com.alibaba.nacos.api.NacosFactory;
import com.alibaba.nacos.api.config.ConfigService;
import com.alibaba.nacos.api.exception.NacosException;
 
import java.util.List;
import java.util.Properties;
 
public class SentinelNacosConfig {
 
    private static final String GROUP_ID = "DEFAULT_GROUP";
    private static final String FLOW_DATA_ID = "sentinel-flow-rules";
    private static final String NACOS_SERVER_ADDR = "127.0.0.1:8848";
 
    public static void main(String[] args) throws NacosException {
        // 初始化配置服务
        initConfigService(NACOS_SERVER_ADDR);
 
        // 加载流控规则
        loadFlowRules();
    }
 
    private static void initConfigService(String nacosServerAddr) throws NacosException {
        Properties properties = new Properties();
        properties.put("serverAddr", nacosServerAddr);
        ConfigService configService = NacosFactory.createConfigService(properties);
        // 订阅配置，并且对获取到的配置进行处理
        configService.addListener(FLOW_DATA_ID, GROUP_ID, (configInfo, e) -> {
            if (e == null) {
                // 处理配置变化，更新规则
                String content = configInfo.getContent();
                updateRules(content);
            }
        });
    }
 
    private static void loadFlowRules() {
        // 从Nacos读取流控规则配置
        ReadableDataSource<String, List<FlowRule>> flowRuleDataSource = new NacosDataSource<>(FLOW_DATA_ID, GROUP_ID, content -> JSON.parseArray(content, FlowRule.class));
        // 加载流控规则
        FlowRuleManager.register2Property(flowRuleDataSource.getProperty());
    }
 
    private static void updateRules(String content) {
        List<FlowRule> rules = JSON.parseArray(content, FlowRule.class);
        FlowRuleManager.loadRules(rules);
    }
}

这段代码展示了如何使用Sentinel和Nacos进行规则配置的持久化。首先，它通过NacosFactory创建了一个ConfigService实例，用于从Nacos配置中心订阅和获取配置信息。当配置信息变更时，它会调用updateRules方法来更新本地的流控规则。这个例子简洁地展示了如何将Sentinel与Nacos整合，并实现动态规则配置。

- 阅读更多 -

Django2自带用户登录注册功能总结_django用户登录与注册内置模型

System

2024-09-06

所有,数据库

在Django中，可以使用内置的User模型以及auth应用提供的视图和表单来快速实现用户的登录和注册功能。以下是一个简单的例子：

首先，确保在settings.py中启用了django.contrib.auth和django.contrib.contenttypes：




INSTALLED_APPS = [
    # ...
    'django.contrib.auth',
    'django.contrib.contenttypes',
    # ...
]

然后，在urls.py中添加登录和注册的URL：




from django.urls import path
from django.contrib.auth import views as auth_views
 
urlpatterns = [
    # ...
    path('login/', auth_views.LoginView.as_view(template_name='login.html'), name='login'),
    path('logout/', auth_views.LogoutView.as_view(), name='logout'),
    path('password_change/', auth_views.PasswordChangeView.as_view(template_name='password_change_form.html'), name='password_change'),
    path('password_change/done/', auth_views.PasswordChangeDoneView.as_view(template_name='password_change_done.html'), name='password_change_done'),
    path('password_reset/', auth_views.PasswordResetView.as_view(template_name='password_reset_form.html'), name='password_reset'),
    path('password_reset/done/', auth_views.PasswordResetDoneView.as_view(template_name='password_reset_done.html'), name='password_reset_done'),
    path('reset/<uidb64>/<token>/', auth_views.PasswordResetConfirmView.as_view(template_name='password_reset_confirm.html'), name='password_reset_confirm'),
    path('reset/done/', auth_views.PasswordResetCompleteView.as_view(template_name='password_reset_complete.html'), name='password_reset_complete'),
    # ...
]

接下来，创建对应的HTML模板文件，例如login.html，logout.html，password_change_form.html等，在模板中可以使用Django的模板标签来展示表单和操作按钮。

最后，确保你的项目已经收集了静态文件和媒体文件（如果你使用了Django的默认STATIC_URL和MEDIA_URL设置）。

这样，你就有了一个基于Django内置User模型的登录和注册系统。你可以通过URL访问这些视图，并在对应的HTML模板中填写表单来完成用户的登录注册等操作。

- 阅读更多 -

PostgreSQL数据库timestamp数据类型精度进位问题

System

2024-09-06

所有,数据库




-- 假设我们有一个需要存储时间戳的表格，并且我们希望精确到微秒
CREATE TABLE example_table (
    id SERIAL PRIMARY KEY,
    timestamp_us TIMESTAMP(6) WITH TIME ZONE NOT NULL
);
 
-- 插入一个时间戳，注意这里我们提供了微秒的精度
INSERT INTO example_table (timestamp_us) VALUES ('2023-04-01 12:00:00.123456+00');
 
-- 查询表格，以验证数据的存储精度
SELECT * FROM example_table;

这个简单的例子展示了如何在PostgreSQL中创建一个表格并定义一个timestamp数据类型，该类型能够存储微秒级别的时间戳。同时，我们也展示了如何插入和查询这种类型的数据。这对于需要在数据库中处理精确到微秒级别时间戳的开发者来说是一个有价值的参考。

- 阅读更多 -

MyBatis的数据库连接与池化案例

System

2024-09-06

所有,java




<configuration>
    <!-- 配置环境 -->
    <environments default="development">
        <environment id="development">
            <!-- 配置事务管理器 -->
            <transactionManager type="JDBC"/>
            <!-- 配置数据源，使用内置的POOLED连接池 -->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis_db?serverTimezone=UTC"/>
                <property name="username" value="root"/>
                <property name="password" value="password"/>
            </dataSource>
        </environment>
    </environments>
    <!-- 其他配置 -->
</configuration>

这个配置文件定义了MyBatis的环境，其中包含了一个事务管理器和数据源。数据源使用了内置的POOLED类型，这意味着MyBatis将会使用JDBC连接池来管理数据库连接。这个配置文件为开发者提供了一个简单的示例，展示了如何配置MyBatis以连接到数据库并使用连接池。

- 阅读更多 -

如何在 Spring Cloud 项目中配置 Gateway 的详细说明

System

2024-09-06

所有,java

在Spring Cloud项目中配置Gateway网关，你需要在application.yml或application.properties文件中添加Gateway的配置。以下是一个配置示例：




spring:
  cloud:
    gateway:
      routes:
        - id: my_route
          uri: http://localhost:8081
          predicates:
            - Path=/myservice/**
        - id: my_route2
          uri: http://localhost:8082
          predicates:
            - Path=/myservice2/**

在这个配置中：

spring.cloud.gateway.routes定义了路由规则。
id是路由的唯一标识。
uri是目标服务的地址。
predicates定义了路由的条件，这里的条件是请求的路径匹配指定模式。

这个配置会将所有匹配/myservice/**的请求转发到http://localhost:8081，匹配/myservice2/**的请求转发到http://localhost:8082。

确保你的项目已经添加了Spring Cloud Gateway依赖：




<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>

启动类上添加@EnableSpringCloudGateway注解启用Gateway功能：




import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.gateway.route.RouteLocator;
import org.springframework.cloud.gateway.route.builder.RouteLocatorBuilder;
import org.springframework.context.annotation.Bean;
 
@SpringBootApplication
@EnableDiscoveryClient
public class GatewayApplication {
 
    public static void main(String[] args) {
        SpringApplication.run(GatewayApplication.class, args);
    }
 
    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
                .route("my_route", r -> r.path("/myservice/**")
                        .uri("http://localhost:8081"))
                .route("my_route2", r -> r.path("/myservice2/**")
                        .uri("http://localhost:8082"))
                .build();
    }
}

以上代码展示了如何在Spring Cloud Gateway中配置路由规则，并通过Java配置类进行路由的定制。

System

2024-09-06

所有,数据库

解释：

这个错误表明尝试从一个远程客户端连接到PostgreSQL服务器的5432端口时，连接被拒绝。可能的原因包括：

PostgreSQL服务器没有运行在远程服务器上。
防火墙设置阻止了远程连接。
PostgreSQL配置文件postgresql.conf中的listen_addresses和port设置不允许远程连接。
PostgreSQL的身份验证配置可能不允许远程连接。

解决方法：

确认PostgreSQL服务正在运行。
检查服务器的防火墙设置，确保5432端口对于希望进行连接的客户端是开放的。
登录到PostgreSQL服务器，查看配置文件postgresql.conf中的listen_addresses是否设置为*'或者包含0.0.0.0，并且port是否设置为5432。
确认pg_hba.conf文件中的身份验证设置允许远程连接。
如果修改了配置文件，重启PostgreSQL服务使更改生效。

如果以上步骤不能解决问题，可能需要进一步检查网络连接，查看是否有其他安全设置（如VPNs或者中间防火墙设备）可能导致连接问题。

- 阅读更多 -

Spring Cloud微服务实战技术文档太强了，从进阶到实战步骤都有

System

2024-09-06

所有,java

由于您提出的query是关于Spring Cloud微服务的实战技术文档，我无法提供具体的代码实例，因为这类文档通常涵盖了从构建微服务架构的高级概念，到具体代码实现的实战步骤。

然而，我可以提供一个简单的例子来说明如何在Spring Cloud中创建和注册一个服务。

假设您正在使用Spring Cloud Netflix技术栈，并希望创建一个简单的服务提供者（例如，一个REST API）。

步骤1: 创建一个Spring Boot项目，并添加Spring Cloud依赖。




<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
</dependencies>

步骤2: 在Spring Boot主类上添加@EnableDiscoveryClient注解，以便将服务注册到Eureka。




import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
 
@SpringBootApplication
@EnableDiscoveryClient
public class MyServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyServiceApplication.class, args);
    }
}

步骤3: 创建一个REST控制器。




import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
public class MyController {
    @GetMapping("/hello")
    public String hello() {
        return "Hello from MyService!";
    }
}

步骤4: 配置application.properties或application.yml文件，包括Eureka服务器的位置。




spring.application.name=my-service
server.port=8080
eureka.client.service-url.defaultZone=http://localhost:8761/eureka/

这个简单的例子展示了如何创建一个服务，将其注册到Eureka服务器，并通过REST API对外提供服务。在实践中，您需要根据具体的业务需求和架构设计来扩展和定制这个基本框架。

System

2024-09-06

所有,java

CVE-2016-5388是Apache Tomcat服务器中的一个安全漏洞，该漏洞允许未授权攻击者通过发送特制的HTTP请求来远程执行代码，影响了Tomcat 6到9的版本。

复现该漏洞的步骤通常包括：

确保你有一个受影响版本的Tomcat服务器。
发送一个特制的HTTP请求，尝试利用此漏洞。

以下是使用Burp Suite发送漏洞利用请求的简化步骤：

启动Burp Suite代理。
配置浏览器或其他客户端以通过Burp Suite代理发送流量。
在Burp Suite中捕获并修改请求。
发送修改后的请求，如果服务器响应表明漏洞存在，则说明复现成功。

实际的请求可能需要具体分析，但基本思路是发送一个特制的请求利用Tomcat的某些处理逻辑。

请注意，未经授权的攻击行为是非法的，本答案仅用于教育目的，目的是为了展示如何测试和验证漏洞。如果你在自己的系统上复现了该漏洞，请确保遵守所有适用的法律法规，并在必要时进行清理。

- 阅读更多 -