1. 首页
  2. 分类
  3. 后端技术
mongodb知识点
System
2024-08-29
所有,数据库

MongoDB是一个基于分布式文件存储的开源数据库系统，旨在为WEB应用提供可扩展的高性能数据存储解决方案。MongoDB将数据存储为文档，这些文档是以BSON（Binary JSON）格式存储的，并且MongoDB支持丰富的查询语言，以及通过复制和故障转移提供高可用性。

以下是一些MongoDB的常见知识点和示例代码：

  1. 连接MongoDB数据库

Python代码：




from pymongo import MongoClient
 
client = MongoClient('localhost', 27017)
db = client['test_database']
collection = db['test_collection']
  1. 插入文档

Python代码：




post = {"name": "Alice", "age": 25}
collection.insert_one(post)
  1. 查询文档

Python代码：




# 查询所有文档
for post in collection.find():
    print(post)
 
# 查询特定文档
for post in collection.find({"name": "Alice"}):
    print(post)
  1. 更新文档

Python代码：




collection.update_one({"name": "Alice"}, {"$set": {"age": 30}})
  1. 删除文档

Python代码：




collection.delete_one({"name": "Alice"})
  1. 创建索引

Python代码：




collection.create_index([("name", pymongo.ASCENDING)])
  1. 聚合查询

Python代码：




pipeline = [
    {"$match": {"name": "Alice"}},
    {"$group": {"_id": "$age", "num_posts": {"$sum": 1}}}
]
 
for post in collection.aggregate(pipeline):
    print(post)
  1. 复制和故障转移

MongoDB支持主从复制和副本集，以保证数据的高可用性和故障恢复。

以上是一些基本的MongoDB操作，实际应用中可能还会涉及到更复杂的操作，如分片、事务等。

- 阅读更多 -
Spring Cloud Loadbalancer 实现客户端负载均衡
System
2024-08-29
所有,java



import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.web.reactive.function.client.WebClient;
 
public class LoadBalancedWebClient {
    private final WebClient.Builder webClientBuilder;
    private final LoadBalancerClient loadBalancer;
 
    public LoadBalancedWebClient(WebClient.Builder webClientBuilder, LoadBalancerClient loadBalancer) {
        this.webClientBuilder = webClientBuilder;
        this.loadBalancer = loadBalancer;
    }
 
    public WebClient createWebClient(String serviceId) {
        ServiceInstance instance = this.loadBalancer.choose(serviceId);
        String url = String.format("http://%s:%s", instance.getHost(), instance.getPort());
        return webClientBuilder.baseUrl(url).build();
    }
}

这段代码展示了如何使用Spring Cloud LoadBalancer客户端来选择一个服务实例，并构建一个WebClient以用于对该实例发起请求。LoadBalancerClient的choose方法根据提供的服务ID选择一个实例，然后将实例的主机和端口拼接成完整的URL，传递给WebClient.Builder来创建一个新的WebClient实例。这个实例之后可以用来发送HTTP请求到该服务。

- 阅读更多 -
Oracle 12c 关闭连接
System
2024-08-29
所有,数据库

在Oracle 12c中关闭数据库连接通常是通过在客户端应用程序中执行相关的数据库断开操作来完成的。这个操作可以是显式的，也可以是隐式的，取决于你使用的编程语言和数据库驱动。

以下是一些常见的编程语言和数据库驱动关闭连接的例子：

JDBC (Java):




Connection conn = null;
try {
    // 获取连接
    conn = DriverManager.getConnection("jdbc:oracle:thin:@hostname:port:sid", "username", "password");
    // ... 执行数据库操作 ...
} finally {
    if (conn != null && !conn.isClosed()) {
        // 关闭连接
        conn.close();
    }
}

Python (使用 cx\_Oracle):




import cx_Oracle
 
conn = cx_Oracle.connect("username/password@hostname:port/sid")
# 或者使用TNS连接
# conn = cx_Oracle.connect("username/password@hostname")
 
# ... 执行数据库操作 ...
 
# 关闭连接
conn.close()

Node.js (使用 oracledb):




const oracledb = require('oracledb');
 
async function main() {
    let connection;
    try {
        connection = await oracledb.getConnection({
            user          : "username",
            password      : "password",
            connectString : "hostname:port/sid"
        });
        // ... 执行数据库操作 ...
    } finally {
        if (connection) {
            // 关闭连接
            await connection.close();
        }
    }
}
 
main().catch(console.error);

请注意，在实际的生产环境中，应该始终确保在完成数据库操作后正确关闭连接，以避免资源浪费或潜在的数据库连接泄露问题。

- 阅读更多 -
[pgrx开发postgresql数据库扩展]7.返回序列的函数编写表序列
System
2024-08-29
所有,数据库



#include "postgres.h"
#include "fmgr.h"
#include "catalog/pg_type.h"
#include "access/htup_details.h"
#include "funcapi.h"
#include "utils/builtins.h"
 
/*
 * 函数声明
 */
PG_MODULE_MAGIC;
 
PG_FUNCTION_INFO_V1(pg_rxtest_seq);
 
/*
 * pg_rxtest_seq函数的实现
 */
Datum
pg_rxtest_seq(PG_FUNCTION_ARGS)
{
    FuncCallContext *funcctx;
    int            call_cntr;
    int            max_calls;
 
    if (SRF_IS_FIRSTCALL())
    {
        /* 设置返回记录的元组描述 */
        TupleDesc    tupdesc = create_function_result_tupdesc2("seq_id", "seq_value");
 
        /* 分配内存，初始化funcctx */
        funcctx = SRF_FIRSTCALL_INIT();
 
        /* 设置返回结果的元组描述 */
        funcctx->tuple_desc = BlessTupleDesc(tupdesc);
 
        /* 设置max_calls为1，表示只返回一个元组 */
        max_calls = 1;
 
        /* 保存max_calls值 */
        funcctx->max_calls = max_calls;
 
        /* 在这里可以添加获取序列值的逻辑 */
        /* 例如：funcctx->user_fctx = (void *) get_sequence_value(); */
 
        /* 这里返回一个空的Datum，实际逻辑在后续调用中实现 */
        MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
    }
 
    /* 这里实现逐次返回结果的逻辑 */
    funcctx = SRF_PERCALL_SETUP();
 
    /* 调用计数器，范围从0到max_calls-1 */
    call_cntr = funcctx->call_cntr;
 
    /* 判断是否有更多的行需要处理 */
    if (call_cntr < funcctx->max_calls)
    {
        /* 创建返回的元组 */
        Datum        values[2];
        bool        nulls[2] = {false, false};
        HeapTuple    tuple;
 
        /* 这里填充元组数据，例如：
         * values[0] = Int32GetDatum(call_cntr);
         * values[1] = Float4GetDatum((float4)call_cntr);
         */
 
        /* 创建元组 */
        tuple = heap_form_tuple(funcctx->tuple_desc, values, nulls);
 
        /* 递增调用计数器 */
        funcctx->call_cntr = call_cntr + 1;
 
        /* 返回元组 */
        SRF_RETURN_NEXT(funcctx, HeapTupleGetDatum(tuple));
    }
 
    /* 没有更多的行，结束调用 */
    SRF_RETURN_DONE(funcctx);
}

这个代码实例提供了一个简化的pg_rxtest_seq函数的实现，它创建了一个返回单个元组的函数。在实际的函数中，你需要替换创建元组数据的部分，以便根据实际需求获取和返回序列值。这个例子教会开发者如何设计和实现一个简单的SQL函数，它可以在数据库中被调用并返回一个或多个结果。

- 阅读更多 -
项目实战--SpringBoot整合EasyExcel实现数据导入导出
System
2024-08-29
所有,java



import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.write.metadata.WriteSheet;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
 
import java.util.ArrayList;
import java.util.List;
 
@RestController
@RequestMapping("/excel")
public class ExcelController {
 
    // 导入数据
    @PostMapping("/import")
    public String importData(MultipartFile file) {
        try {
            EasyExcel.read(file.getInputStream(), DataModel.class, new DataModelListener()).sheet().doRead();
            return "导入成功";
        } catch (Exception e) {
            e.printStackTrace();
            return "导入失败";
        }
    }
 
    // 导出数据
    @GetMapping("/export")
    public void exportData(HttpServletResponse response) {
        List<DataModel> data = new ArrayList<>();
        // 添加数据到data
        String fileName = "exportedData.xlsx";
        try {
            EasyExcel.write(response.getOutputStream(), DataModel.class)
                    .sheet("数据")
                    .doWrite(data);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
 
// 实体类映射Excel表头
class DataModel {
    // 定义属性，与Excel表头对应
}
 
// 监听器，用于读取Excel数据
class DataModelListener extends AnalysisEventListener<DataModel> {
    @Override
    public void invoke(DataModel data, AnalysisContext context) {
        System.out.println("读取到数据：" + data);
        // 处理读取到的数据
    }
 
    @Override
    public void doAfterAllAnalysed(AnalysisContext context) {
        // 所有数据解析完成后做的事情
    }
}

这个代码实例展示了如何使用EasyExcel库在SpringBoot应用中导入和导出数据。导入时，使用EasyExcel.read()方法读取文件，并使用自定义的监听器来处理读取到的数据。导出时，使用EasyExcel.write()方法将数据写入响应输出流中，以便将其作为Excel文件下载。

- 阅读更多 -
在项目中使用Spring Cloud Alibaba Sentinel组件
System
2024-08-29
所有,java

Spring Cloud Alibaba Sentinel 是阿里巴巴开源的一个面向分布式服务架构的轻量级流量控制框架，主要以流量为切入点，提供流量控制、熔断降级、系统负载保护等功能。

在Spring Cloud项目中使用Sentinel，你需要做以下几步：

  1. 引入Sentinel依赖：



<dependencies>
    <!-- Spring Cloud Alibaba Sentinel -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
    </dependency>
</dependencies>
  1. 在application.yml或application.properties中配置Sentinel相关属性，例如：



spring:
  cloud:
    sentinel:
      transport:
        dashboard: 127.0.0.1:8080 # Sentinel dashboard 地址
        port: 8719 # 默认端口，兼容Sentinel 1.6.0及以下版本
      # 若使用Sentinel 1.7.0及以上版本，需要额外配置如下：
      eager: true
  1. 在你的服务中使用Sentinel提供的注解或者编程方式来定义资源，并设置流量控制规则：



import com.alibaba.csp.sentinel.annotation.SentinelResource;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
public class TestController {
 
    @GetMapping("/test")
    @SentinelResource(value = "test", blockHandler = "handleException")
    public String test() {
        return "Hello, Sentinel";
    }
 
    public String handleException(BlockException ex) {
        return "Error: " + ex.getClass().getSimpleName();
    }
}
  1. 启动Sentinel控制台（Dashboard），并启动你的Spring Cloud应用，你可以在Sentinel控制台中看到你的服务并实时监控流量情况。

以上是一个简单的使用Sentinel的例子，具体的使用方法和配置可能根据你的具体需求有所不同。

- 阅读更多 -
PostgreSQL的学习心得和知识总结（一百二十）|语法级自上而下完美实现MySQL数据库的 update/delete limit 的实现方案
System
2024-08-29
所有,数据库

在PostgreSQL中，实现MySQL语法的自上而下完美转换，可以通过创建一个函数来转换SQL语句。以下是一个简化的例子，演示如何转换一个简单的SELECT语句。




CREATE OR REPLACE FUNCTION mysql_to_pg(mysql_query text)
RETURNS text AS $$
BEGIN
    -- 这里可以添加具体的转换逻辑，例如替换函数、列名等
    -- 简单示例，只是将MySQL的LIMIT转换为PostgreSQL的LIMIT
    IF mysql_query ~ 'LIMIT [0-9]+' THEN
        mysql_query := regexp_replace(mysql_query, 'LIMIT [0-9]+', 'LIMIT ' || '100');
    END IF;
 
    RETURN mysql_query;
END;
$$ LANGUAGE plpgsql IMMUTABLE;
 
-- 使用函数转换SQL语句
SELECT mysql_to_pg('SELECT * FROM users WHERE id > 10 LIMIT 20');

在这个例子中，我们创建了一个名为mysql_to_pg的函数，它接收一个文本参数mysql_query，并返回转换后的PostgreSQL兼容的查询。函数内部使用正则表达式检查输入的查询是否包含MySQL的LIMIT语句，并将其转换为PostgreSQL的LIMIT语句，默认为100行。

这只是一个简化的例子，实际转换过程可能会更加复杂，涉及函数、存储过程、触发器等的转换，以及对MySQL专有函数和表达式的替换。

- 阅读更多 -
SpringBoot上传超大文件导致OOM，完美解决办法
System
2024-08-29
所有,java

解释：

SpringBoot中OOM（Out of Memory）通常发生在上传文件时，如果文件过大且没有适当的配置，就可能导致JVM内存溢出。

解决方法：

  1. 增加JVM内存限制。可以通过调整启动参数中的-Xmx和-Xms来增大堆内存的最大值和初始值。例如：java -Xmx4096m -Xms4096m -jar yourapp.jar。
  2. 配置MultipartResolver的bufferSize。在Spring Boot应用中，可以在application.properties或application.yml中设置：



spring.servlet.multipart.max-file-size=128MB
spring.servlet.multipart.max-request-size=128MB
spring.servlet.multipart.buffer-size=1048576

这将设置文件大小限制和请求大小限制，并为文件上传提供更大的缓冲区。

  1. 使用分块上传。如果文件过大，可以考虑实现分块上传机制，每次只上传一小部分数据。
  2. 使用外部存储。如果文件过大，建议使用外部存储，如Amazon S3或者MinIO等，将文件存储在云服务上，而不是JVM堆内存中。
  3. 调整JVM参数，例如-XX:+HeapDumpOnOutOfMemoryError来获取内存溢出时的堆转储，用于后续的分析和调试。
  4. 使用流式上传。在Spring Boot中，可以使用DataWebClient来实现基于反应式流的文件上传，这样可以避免一次性加载整个文件到内存中。

注意：在实施以上解决方案时，应当根据具体场景和需求选择合适的方法，并进行充分的测试以确保上传功能稳定可靠。

- 阅读更多 -
PostgreSQL中json数据类型介绍
System
2024-08-29
所有,数据库

在PostgreSQL中，json 和 jsonb 数据类型用于存储 JSON 格式的数据。

  • json 类型存储的是文本格式的 JSON 数据，存储时会根据输入格式保留空格符。
  • jsonb 类型是二进制格式的 JSON 数据，在存储和检索时会优化处理，并提供更高的性能。

主要区别：

  1. 存储空间：json 类型会占用更多的存储空间，因为它保留了输入格式中的空格。而 jsonb 类型更紧凑，通常占用更少的存储空间。
  2. 处理速度：由于 jsonb 类型以二进制格式存储，因此在处理查询和索引时性能更好。
  3. 功能支持：jsonb 类型提供了更多的功能和操作方法，例如可以创建索引，而 json 类型则不可以。

实例代码：




-- 创建一个包含 json 类型字段的表
CREATE TABLE example_json (
    id serial PRIMARY KEY,
    data json
);
 
-- 插入 JSON 数据
INSERT INTO example_json (data) VALUES ('{"name": "John", "age": 30}');
 
-- 查询 JSON 数据
SELECT * FROM example_json WHERE data->>'name' = 'John';
 
-- 创建一个包含 jsonb 类型字段的表
CREATE TABLE example_jsonb (
    id serial PRIMARY KEY,
    data jsonb
);
 
-- 插入 JSONB 数据
INSERT INTO example_jsonb (data) VALUES ('{"name": "John", "age": 30}');
 
-- 查询 JSONB 数据
SELECT * FROM example_jsonb WHERE data->>'name' = 'John';

在实际应用中，推荐尽可能使用 jsonb 类型，因为它提供了更多的功能和更好的性能。

- 阅读更多 -
--查看某个表及其组件所占的各个表空间的大小
System
2024-08-29
所有,数据库

在Oracle数据库中，您可以使用以下SQL查询来查看某个表及其组件所占用的各个表空间的大小：




SELECT
    dt.tablespace_name,
    SUM(dd.bytes) / 1024 / 1024 AS "Size (MB)"
FROM
    dba_data_files dd,
    dba_segments dg,
    dba_tables dt
WHERE
    dd.tablespace_name = dt.tablespace_name
    AND dt.table_name = '您的表名'
    AND dt.owner = '您的表所属用户'
    AND dg.tablespace_name = dt.tablespace_name
GROUP BY
    dt.tablespace_name;

请将 '您的表名' 和 '您的表所属用户' 替换成实际的表名和所有者名。

这个查询会返回指定表及其所有组件所占用的每个表空间的大小（以MB为单位）。如果您想要查看更详细的信息，比如每个段（segment）的大小，您可以去掉 dt.table_name 和 dt.owner 的条件，这样就可以看到整个数据库中所有表和索引占用的表空间大小。

- 阅读更多 -
Copyright © 2026 Tech Blog
All Right Reserved | 京ICP备19053165号