1. 首页
  2. 分类
  3. 后端技术
SpringBoot3中Swagger整合knife4j和springdoc的配置说明
System
2024-09-01
所有,java

在Spring Boot 3中，你可以选择使用Swagger来记录REST APIs，也可以选择使用Knife4j，它是Swagger的一个增强解决方案，或者使用SpringDoc，这是另一种API文档生成工具。

以下是整合这三种工具的基本配置示例：

Swagger (使用springfox)

  1. 添加依赖：



<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-boot-starter</artifactId>
    <version>3.0.0</version>
</dependency>
  1. 配置Swagger：



@Configuration
@EnableSwagger2
public class SwaggerConfig {
    @Bean
    public Docket api() {
        return new Docket(DocumentationType.SWAGGER_2).select()
                .apis(RequestHandlerSelectors.any())
                .paths(PathSelectors.any())
                .build();
    }
}

访问地址：http://localhost:8080/swagger-ui.html

Knife4j (基于Swagger)

  1. 添加依赖：



<dependency>
    <groupId>com.github.xiaoymin</groupId>
    <artifactId>knife4j-spring-boot-starter</artifactId>
    <version>3.0.3</version>
</dependency>
  1. 配置Knife4j (通常不需要额外配置)：

访问地址：http://localhost:8080/doc.html

SpringDoc

  1. 添加依赖：



<dependency>
    <groupId>org.springdoc</groupId>
    <artifactId>springdoc-openapi-ui</artifactId>
    <version>1.6.10</version>
</dependency>
  1. 配置SpringDoc：



@Configuration
public class SpringDocConfig {
    @Bean
    public OpenAPI customOpenAPI() {
        return new OpenAPI()
                .info(new Info().title("SpringDoc API")
                .description("This is a sample SpringDoc API")
                .version("0.0.1-SNAPSHOT"));
    }
}

访问地址：http://localhost:8080/swagger-ui/index.html

请注意，这些配置示例可能需要根据你的具体需求进行调整。每个工具都有其特点，你可以根据项目需求和个人喜好选择合适的工具。

- 阅读更多 -
django连接数据库
System
2024-09-01
所有,数据库

在Django中连接数据库需要配置settings.py文件中的DATABASES字典。以下是一个使用SQLite作为数据库的配置示例：




# settings.py
 
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',
    }
}

如果你想使用其他数据库，比如PostgreSQL或MySQL，你需要安装相应的数据库驱动（如psycopg2或mysqlclient），并更新DATABASES配置，如下所示：

PostgreSQL示例：




# settings.py
 
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'mydatabase',
        'USER': 'mydatabaseuser',
        'PASSWORD': 'mypassword',
        'HOST': 'localhost',
        'PORT': '5432',
    }
}

MySQL示例：




# settings.py
 
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'mydatabase',
        'USER': 'mydatabaseuser',
        'PASSWORD': 'mypassword',
        'HOST': 'localhost',
        'PORT': '3306',
    }
}

确保你已经安装了所需的数据库驱动，并且你的数据库服务器正在运行。之后，你可以运行以下命令来创建数据库表：




python manage.py migrate

这将根据你的模型定义创建或更新数据库表。

- 阅读更多 -
数据持久化之嵌入式数据库-SQLite
System
2024-09-01
所有,数据库



import sqlite3
 
# 连接到SQLite数据库
# 数据库文件是test.db，如果文件不存在，会自动在当前目录创建:
conn = sqlite3.connect('test.db')
 
# 创建一个Cursor:
cursor = conn.cursor()
 
# 执行一条SQL语句，创建user表:
cursor.execute('CREATE TABLE IF NOT EXISTS user (id VARCHAR(20) PRIMARY KEY, name VARCHAR(20))')
 
# 关闭Cursor:
cursor.close()
 
# 关闭Connection:
conn.close()

这段代码演示了如何使用Python的sqlite3库来连接SQLite数据库，创建一个名为user的表，其中包含id和name两个字段，其中id是主键。如果表已经存在，则不会重复创建。最后，代码关闭了Cursor和Connection对象，释放资源。

- 阅读更多 -
Django的模板标签相关知识累
System
2024-09-01
所有,数据库

在Django中，模板标签用于在模板中插入动态内容。它们通常用于显示数据库内容，循环和条件判断等。

  1. 自定义模板标签

自定义模板标签的步骤如下：

  • 定义python函数，并使用@register.simple\_tag装饰器进行装饰。
  • 在模板中使用加载你的自定义模板标签的模板标签。
  • 使用你的自定义模板标签。

例如，我们可以创建一个模板标签，该标签将两个数字相加：




# myapp/templatetags/my_tags.py
from django import template
 
register = template.Library()
 
@register.simple_tag
def add(a, b):
    return a + b

然后在模板中使用这个标签：




{% load my_tags %}
 
{% add 10 20 %}
  1. 模板inclusion标签

模板inclusion标签用于包含其他模板的内容。它类似于python中的import语句。

例如，我们可以创建一个名为my_inclusion.html的模板，并在其中写入：




<h1>This is an inclusion template</h1>

然后在主模板中包含这个模板：




{% include "myapp/my_inclusion.html" %}
  1. 模板继承

模板继承允许你创建一个基本模板，它定义了子模板可以重写的区域。这样可以使你的html代码保持DRY(Don't Repeat Yourself)。

例如，我们可以创建一个名为base.html的基本模板，并在其中定义可重写的区域：




<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>{% block title %}My amazing site{% endblock %}</title>
</head>
<body>
    <div id="content">{% block content %}{% endblock %}</div>
    <div id="footer">{% block footer %}Copyright 2022{% endblock %}</div>
</body>
</html>

然后，我们可以创建一个名为home.html的子模板，并继承base.html，然后重写其中的块：




{% extends "base.html" %}
 
{% block title %}Home Page{% endblock %}
 
{% block content %}
<h1>Welcome to the home page</h1>
<p>This is some lorem ipsum dolor sit amet, consectetur adipiscing elit.</p>
{% endblock %}

以上就是Django模板标签的一些基本知识和使用方法。

- 阅读更多 -
Spring Boot 配置双数据源
System
2024-09-01
所有,java

在Spring Boot中配置双数据源通常涉及以下步骤：

  1. 配置数据源属性。
  2. 创建数据源实例。
  3. 配置EntityManagerFactory和TransactionManager。
  4. 配置@Configuration类来创建两个不同的Spring容器，每个容器使用不同的数据源。

以下是一个简化的示例代码：




@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
        basePackages = "com.example.repository.first",
        entityManagerFactoryRef = "firstEntityManager",
        transactionManagerRef = "firstTransactionManager")
public class FirstDataSourceConfig {
 
    @Bean
    @Primary
    @ConfigurationProperties(prefix = "spring.datasource.first")
    public DataSource firstDataSource() {
        return DataSourceBuilder.create().build();
    }
 
    @Bean
    public LocalContainerEntityManagerFactoryBean firstEntityManager(EntityManagerFactoryBuilder builder) {
        return builder
                .dataSource(firstDataSource())
                .packages("com.example.entity.first")
                .persistenceUnit("first")
                .build();
    }
 
    @Bean
    @Primary
    public PlatformTransactionManager firstTransactionManager(
            @Qualifier("firstEntityManager") EntityManagerFactory entityManagerFactory) {
        return new JpaTransactionManager(entityManagerFactory);
    }
}
 
@Configuration
@EnableJpaRepositories(
        basePackages = "com.example.repository.second",
        entityManagerFactoryRef = "secondEntityManager",
        transactionManagerRef = "secondTransactionManager")
public class SecondDataSourceConfig {
 
    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.second")
    public DataSource secondDataSource() {
        return DataSourceBuilder.create().build();
    }
 
    @Bean
    public LocalContainerEntityManagerFactoryBean secondEntityManager(EntityManagerFactoryBuilder builder) {
        return builder
                .dataSource(secondDataSource())
                .packages("com.example.entity.second")
                .persistenceUnit("second")
                .build();
    }
 
    @Bean
    public PlatformTransaction
- 阅读更多 -
Redisson集成SpringBoot
System
2024-09-01
所有,redis

为了在Spring Boot中集成Redisson，你需要做以下几步：

  1. 添加Redisson的依赖到你的pom.xml文件中。
  2. 创建Redisson的配置文件。
  3. 配置Redisson的Bean。

以下是具体步骤和示例代码：

  1. 添加Redisson依赖到pom.xml：



<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.16.2</version>
</dependency>
  1. 创建redisson-config.yaml配置文件：



singleServerConfig:
  address: "redis://127.0.0.1:6379"
  1. 配置Redisson的Bean：



import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
 
import java.io.IOException;
 
@Configuration
public class RedissonConfig {
 
    @Bean(destroyMethod="shutdown")
    RedissonClient redisson() throws IOException {
        Config config = Config.fromYAML(new ClassPathResource("redisson-config.yaml").getInputStream());
        return Redisson.create(config);
    }
}

这样，你就可以在Spring Boot应用中使用Redisson提供的各种分布式功能了。

- 阅读更多 -
Spring Boot入门
System
2024-09-01
所有,java

Spring Boot 是一个用于简化 Spring 应用程序初始搭建以及开发过程的框架。以下是一个简单的入门示例：

  1. 首先，你需要在你的项目中添加 Spring Boot 的起步依赖，例如使用 Maven：



<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.1.RELEASE</version>
</parent>
 
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>
  1. 创建一个主应用类，该类含有 Spring Boot 应用程序的主方法：



import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
 
@SpringBootApplication
public class MySpringBootApplication {
 
    public static void main(String[] args) {
        SpringApplication.run(MySpringBootApplication.class, args);
    }
}
  1. 创建一个控制器类来处理 web 请求：



import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
public class HelloWorldController {
 
    @GetMapping("/hello")
    public String hello() {
        return "Hello, Spring Boot!";
    }
}

以上代码就构成了一个简单的 Spring Boot 应用程序，你可以通过运行 main 方法启动服务器，并通过访问 http://localhost:8080/hello 来测试你的应用。

- 阅读更多 -
PostgreSQL 16新特性之正态分布随机数函数
System
2024-09-01
所有,数据库



-- 创建一个名为random_normal_dist的函数，用于生成服从正态分布的随机浮点数
CREATE OR REPLACE FUNCTION random_normal_dist(mean float8, stddev float8)
RETURNS float8 AS $$
DECLARE
    v_const float8;
    v_rand float8;
BEGIN
    -- 计算常数
    v_const := random() * 2.0 * atan(1.0) * (-1.0 / 12.0);
    -- 循环生成随机数直至符合正态分布
    LOOP
        v_rand := exp(v_const - (1.0 / 12.0) * power(v_const, 2.0));
        -- 如果生成的随机数小于等于0，则继续循环
        IF v_rand <= 0 THEN
            CONTINUE;
        END IF;
        -- 使用Box-Muller变换转换为正态分布的随机数
        RETURN mean + stddev * sqrt(-2.0 * log(v_rand)) * sin(v_const);
    END LOOP;
END;
$$ LANGUAGE plpgsql IMMUTABLE STRICT;
 
-- 使用函数生成一个正态分布的随机数，平均值为50，标准差为10
SELECT random_normal_dist(50, 10);

这段代码首先定义了一个名为random_normal_dist的函数，该函数使用Box-Muller变换来生成正态分布的随机浮点数。函数是不可变的（IMMUTABLE）且在计算时如果输入参数是常量，则返回的结果也是常量（STRICT）。最后，提供了一个使用该函数的例子，生成一个平均值为50，标准差为10的正态分布随机数。

- 阅读更多 -
CopilotKit：开源 Copilot 框架，部署应用内 AI 代理，使用 Langchain 自动执行任何任务！
System
2024-09-01
所有,AIGC

CopilotKit 是一个开源框架，用于在应用程序内部部署人工智能代理，并使用 Langchain 自动执行任何命令。以下是一个简单的使用示例：

首先，安装CopilotKit：




pip install copilotkit

然后，使用CopilotKit创建一个简单的应用内 AI 代理，例如，一个处理文本查询并使用 OpenAI 的 GPT-3 模型进行响应的代理：




from copilotkit import Copilot, OpenAIProxy
 
# 初始化一个 OpenAI 代理
openai_proxy = OpenAIProxy(
    openai_api_key="YOUR_OPENAI_API_KEY",
    proxy_name="MyAppCopilot"
)
 
# 初始化 Copilot 实例
copilot = Copilot(
    openai_proxy=openai_proxy,
    # 设置代理响应的最大tokens数量
    max_tokens=75,
)
 
# 使用 while 循环来处理用户的输入，并产生相应的响应
while True:
    user_input = input("请输入您的指令：")
    response = copilot.handle_input(user_input)
    print(response)

在这个例子中，我们创建了一个简单的交互式会话，用户输入指令，AI 代理根据指令作出响应。CopilotKit 使用 Langchain 来理解和执行用户的指令。

请注意，你需要自己的 OpenAI API 密钥，并替换 "YOUR_OPENAI_API_KEY" 为你的 API 密钥。

这只是一个基础示例，CopilotKit 支持更复杂的功能，比如使用多个模型、管理用户历史、优化提示等等。

- 阅读更多 -
POSTGRESQL 关于2023-08-14 数据库自动启动文章中使用KILL 来进行配置RELOAD的问题解释...
System
2024-09-01
所有,数据库

在PostgreSQL中，如果您想要在数据库服务器重启后自动启动数据库，可以配置postgresql.conf文件中的hot_standby参数。但是，hot_standby参数已在较新版本的PostgreSQL中弃用，取而代之的是max_standby_streaming_delay。

如果您的PostgreSQL版本较旧，并且hot_standby参数仍然存在，您可以按如下方式设置：

  1. 打开PostgreSQL配置文件postgresql.conf。
  2. 设置hot_standby为on。
  3. 重启PostgreSQL服务。

如果您使用的是较新版本的PostgreSQL，并希望数据库在服务器重启后自动启动，您可以设置max_standby_archive_delay和max_standby_streaming_delay为适当的值。

请注意，这些设置影响的是PostgreSQL的物理备份服务器（也称为热备份），而不是数据库的自动启动行为。如果您想要在系统重启后自动启动PostgreSQL服务，您需要配置操作系统级别的服务管理器，如systemd或init.d。

在Linux系统上，如果您使用的是systemd，您可以这样配置自动启动：

  1. 找到PostgreSQL的服务文件，通常位于/etc/systemd/system/目录下，并以.service结尾。
  2. 编辑该文件，确保[Service]部分包含Restart=always。
  3. 重新加载systemd配置，并启用服务。

示例：




sudo systemctl edit postgresql.service

在编辑器中添加以下内容：




[Service]
Restart=always

然后保存退出，并执行：




sudo systemctl daemon-reload
sudo systemctl enable postgresql.service

这样配置后，如果PostgreSQL服务意外停止，systemd会尝试重新启动它。

请注意，上述配置只是一个示例，实际路径和配置可能因安装方式和版本而异。如果您需要具体的命令或步骤，请提供更详细的系统信息。

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