Tech Blog

2024-09-03

在PostgreSQL中，执行SQL脚本的方法主要有三种：

使用psql命令行工具。
使用\i或\include在psql中包含一个文件。
在应用程序中使用合适的数据库驱动程序执行SQL脚本。

以下是这三种方法的详细描述和示例：

方法一：使用psql命令行工具

psql是PostgreSQL提供的命令行工具，用于执行SQL和管理数据库。可以使用psql的-f选项来执行文件中的SQL脚本。

示例代码：




psql -U username -d databasename -f scriptfile.sql

在这里，scriptfile.sql是你想要执行的SQL脚本文件。

方法二：使用\i或\include在psql中包含一个文件

你可以在psql的交互式命令行中使用\i或\include命令来执行文件中的SQL脚本。

示例代码：




psql -U username -d databasename

然后在psql提示符下：




\i scriptfile.sql

方法三：在应用程序中使用数据库驱动程序

大多数编程语言都有连接PostgreSQL数据库的驱动程序。你可以使用这些驱动程序来读取SQL脚本文件，然后执行文件中的SQL命令。

以下是一个使用Python的psycopg2驱动程序来执行SQL脚本的例子：




import psycopg2
 
# 连接数据库
conn = psycopg2.connect(dbname="databasename", user="username", password="password")
 
# 创建cursor对象
cur = conn.cursor()
 
# 读取SQL脚本文件
with open('scriptfile.sql', 'r') as f:
    sql_script = f.read()
 
# 执行SQL脚本
cur.execute(sql_script)
 
# 提交事务
conn.commit()
 
# 关闭cursor和连接
cur.close()
conn.close()

在这个例子中，scriptfile.sql是你想要执行的SQL脚本文件。

搭建非maven spring boot项目并且idea进行打包

2024-09-03

在IntelliJ IDEA中搭建非Maven的Spring Boot项目并进行打包，可以按照以下步骤进行：

创建一个新的Spring Initializr项目（不选择Maven构建）。
配置项目的基本信息。
手动添加Spring Boot依赖。
编写代码并进行打包。

步骤如下：

打开IntelliJ IDEA，选择Create New Project -> Spring Initializr。
在Initializr Service URL中填写：https://start.spring.io。
不选择"Add Maven"，点击Next。
填写Group和Artifact信息，选择需要的Spring Boot版本和依赖，点击Next。
选择项目位置，点击Finish。

接下来，IDEA会生成一个基础的Spring Boot项目框架，但不带有Maven支持。

手动添加Spring Boot依赖：

打开项目结构：点击File -> Project Structure。
在Modules部分选择你的项目。
点击Dependencies标签页，点击加号 -> JARs or directories...，选择你需要的Spring Boot依赖JAR包。

编写代码：

在src/main/java下创建你的包和启动类：




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

在src/main/resources下创建application.properties文件，根据需要配置你的属性。

打包项目：

右键点击你的启动类，选择Run 'Application.main()'或者创建一个新的运行配置。
或者使用Build -> Build Artifacts或使用快捷键Build -> Build。

这样，你就可以得到一个非Maven的Spring Boot项目，并且可以在IntelliJ IDEA中进行打包和运行了。

Spring Cloud Gateway Filter执行顺序详解

2024-09-03

Spring Cloud Gateway中的过滤器（Filter）是按照特定的顺序进行执行的。这个顺序可以通过定义过滤器的种类和顺序来控制。

Spring Cloud Gateway内置了多种过滤器，包括pre filters（前置过滤器）和post filters（后置过滤器）。在请求处理生命周期中，pre filters 是在请求被转发前执行的，而post filters 是在响应被发送回客户端前执行的。

过滤器的执行顺序如下：

Pre Filters：按照定义顺序执行。
Routing Filter
Filtering Weight（过滤器权重）：权重越高，越早执行。默认情况下，内置过滤器的权重是：-1（越小越早执行）。
Post Filters：按照定义顺序逆序执行。

如果你想要自定义过滤器的执行顺序，可以通过实现GatewayFilter接口，并使用Ordered接口或者使用@Order注解来指定执行顺序。

以下是一个简单的例子，展示如何自定义过滤器并设置执行顺序：




@Component
@Order(-1) // 设置当前过滤器的执行顺序为-1，即尽可能早执行
public class CustomGatewayFilter implements GatewayFilter, Ordered {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 在这里编写过滤器逻辑
        return chain.filter(exchange); // 继续执行下一个过滤器或处理请求
    }
 
    @Override
    public int getOrder() {
        return -1; // 返回当前过滤器的执行顺序
    }
}

在这个例子中，CustomGatewayFilter实现了GatewayFilter和Ordered接口，并使用@Order(-1)注解来指定执行顺序为最先执行。当然，你也可以通过getOrder()方法返回一个整数来指定顺序。

记住，过滤器的执行顺序是在其定义的时候就已经固定的，如果需要动态改变执行顺序，可能需要通过更复杂的配置或者逻辑来实现。

Activiti与Springboot整合

2024-09-03

在Spring Boot与Activiti整合时，通常使用activiti-spring-boot-starter来简化配置。以下是一个基本的示例：

添加依赖到pom.xml：




<dependencies>
    <!-- Activiti Spring Boot Starter -->
    <dependency>
        <groupId>org.activiti</groupId>
        <artifactId>activiti-spring-boot-starter</artifactId>
        <version>7.1.0.M6</version>
    </dependency>
 
    <!-- Spring Boot Starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
 
    <!-- Spring Boot Starter Test -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

配置application.properties或application.yml：




# Database configuration for Activiti
spring.datasource.url=jdbc:mysql://localhost:3306/activiti?useSSL=false
spring.datasource.username=root
spring.datasource.password=example
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
 
# Activiti specific configuration
spring.activiti.database-schema-update=true
spring.activiti.check-process-definitions=false

创建Spring Boot启动类：




@SpringBootApplication
public class ActivitiSpringBootApplication {
 
    public static void main(String[] args) {
        SpringApplication.run(ActivitiSpringBootApplication.class, args);
    }
}

使用Activiti API：




@Service
public class ActivitiService {
 
    @Autowired
    private RepositoryService repositoryService;
 
    @Autowired
    private RuntimeService runtimeService;
 
    @Autowired
    private TaskService taskService;
 
    public void deployProcess(String processName, String resource) {
        repositoryService.createDeployment()
                .addClasspathResource(resource)
                .deploy();
    }
 
    public void startProcessInstance(String processKey) {
        runtimeService.startProcessInstanceByKey(processKey);
    }
 
    public List<Task> getMyTasks(String assignee) {
        return taskService.createTaskQuery().taskAssignee(assignee).list();
    }
}

以上代码展示了如何在Spring Boot应用程序中使用Activiti。首先，通过\`activiti-sprin

SpringCloud-stream一体化MQ解决方案-消费分区

2024-09-03

在Spring Cloud Stream中，消息分区是一个优化，可以提高消息处理的并行度。以下是一个简单的例子，展示如何在Spring Cloud Stream中使用消息分区。

首先，在application.yml配置文件中启用消息分区：




spring:
  cloud:
    stream:
      bindings:
        input:
          consumer:
            partitioned: true
      kafka:
        binder:
          brokers: localhost:9092
          configuration:
            auto.offset.reset: earliest
            max.partition.fetch.bytes: 2097152

然后，你需要配置分区的数量：




spring.cloud.stream.bindings.input.consumer.partitionCount: 2

接下来，你可以使用@StreamListener注解来监听分区的消息：




@EnableBinding(Sink.class)
public class PartitionedConsumer {
 
    @StreamListener(target = Sink.INPUT, partition = "0")
    public void processPartition0(String message) {
        // 处理分区0的消息
    }
 
    @StreamListener(target = Sink.INPUT, partition = "1")
    public void processPartition1(String message) {
        // 处理分区1的消息
    }
}

在上面的代码中，我们定义了两个分区处理方法processPartition0和processPartition1来处理不同分区的消息。这样，你就可以实现消息的并行处理，提高系统的处理能力。

常用查看表空间和数据文件SQL

2024-09-03

在Oracle数据库中，查看表空间和数据文件的SQL语句如下：

查看表空间：




SELECT TABLESPACE_NAME, STATUS FROM DBA_TABLESPACES;

查看数据文件：




SELECT FILE_NAME, TABLESPACE_NAME, BYTES FROM DBA_DATA_FILES;

查看表空间和数据文件的关系：




SELECT df.tablespace_name,
       df.file_name,
       df.bytes,
       df.autoextensible,
       df.maxbytes,
       ts.status
FROM   dba_data_files df
       JOIN dba_tablespaces ts ON df.tablespace_name = ts.tablespace_name;

这些SQL语句适用于拥有访问DBA\_TABLESPACES和DBA\_DATA\_FILES视图权限的用户。这些视图提供了表空间和数据文件的状态、名称以及它们的容量和自动扩展属性。

Python Django-allauth: 构建全面的用户身份验证系统

2024-09-03




# 导入Django模块
from django.urls import reverse
from django.db import models
from django.contrib.auth.models import AbstractUser
from django.utils.translation import gettext_lazy as _
 
# 定义用户模型
class CustomUser(AbstractUser):
    # 添加额外的字段，例如用户生日
    birth_date = models.DateField(null=True, blank=True, verbose_name=_('birth date'))
 
    # 定义用户的字符串表示
    def __str__(self):
        return self.username
 
    # 定义用户的个人资料URL
    def get_absolute_url(self):
        return reverse('users:detail', kwargs={'username': self.username})
 
# 注册模型

这个代码示例展示了如何扩展Django的内置用户模型AbstractUser来添加额外的字段，并且演示了如何定义用户模型的字符串表示和个人资料URL。这是构建用户身份验证系统的一个基本且常见的需求。

Mozilla 开源 llamafile:大语言模型分发与部署新范式

2024-09-03

所有,AIGC

LlamaIndex 是一个使用 Rust 编写的大型语言模型索引工具，它可以帮助用户快速部署和管理开放AI大模型。

以下是使用 LlamaIndex 部署大型语言模型的基本步骤：

安装 Rust：




curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

安装 LlamaIndex CLI 工具：




cargo install llamaindex-cli --locked

创建一个新的模型索引：




llamaindex new /path/to/model-index

添加一个模型到索引：




llamaindex add /path/to/model-index /path/to/model-file

启动模型服务：




llamaindex serve /path/to/model-index

以上步骤将创建一个新的模型索引，添加一个模型，并启动一个本地服务来查询模型。

LlamaIndex 还支持其他高级功能，例如模型的分布式加载、模型的版本控制、模型的压缩和加密存储等。

注意：以上步骤假设您已经有了一个大型语言模型文件，并且您的系统已经安装了 Rust 编译器。具体的模型文件路径和模型索引路径需要根据实际情况进行替换。

2024-09-03




const mongoose = require('mongoose');
const { Schema } = mongoose;
 
// 连接数据库
mongoose.connect('mongodb://localhost:27017/test', { useNewUrlParser: true });
 
// 创建Schema
const userSchema = new Schema({
  name: String,
  age: Number,
  email: String
});
 
// 创建模型
const User = mongoose.model('User', userSchema);
 
// 查询所有用户，并进行个性化处理
async function queryUsers() {
  try {
    // 选择需要的字段
    let projection = 'name age';
    // 排序条件
    let sort = { age: 1 }; // 1为升序，-1为降序
    // 限制返回的文档数量
    let limit = 5;
    // 跳过指定数量的文档
    let skip = 0;
 
    let users = await User.find({}, projection)
                           .sort(sort)
                           .limit(limit)
                           .skip(skip)
                           .exec();
    console.log(users);
  } catch (error) {
    console.error(error);
  }
}
 
queryUsers();

这段代码首先连接到名为"test"的MongoDB数据库，然后定义了一个用户Schema和模型。在queryUsers函数中，我们使用了find方法来查询所有用户，并通过链式调用设置了字段筛选、排序、限制数量和跳过文档的选项。最后，我们打印出符合条件的用户数据。这个例子展示了如何进行更复杂的查询操作，这对于开发者进一步理解和应用Mongoose库非常有帮助。

Spring Boot Starter：介绍、对比、使用场景和如何自定义

2024-09-03

Spring Boot Starter是Spring Boot的一个核心概念，它提供了一种简单的方法来启用Spring应用程序中的特定功能。Starter通常会包含所需模块的所有依赖，以及对应的自动配置。

介绍：

Starter是一个JAR文件，它包含一组通用功能所需的依赖。例如，如果你想使用Spring Boot创建一个Web应用程序，你可以使用spring-boot-starter-web。

比较：

传统的Spring应用程序需要手动管理依赖，而使用Starter可以简化这个过程。

使用场景：

创建新的Spring Boot应用程序。
将Spring Boot集成到现有的应用程序中。
快速启动新的特性或功能，例如使用Redis、MongoDB、JPA等。

如何自定义Starter：

创建一个新的Maven项目。
添加必要的依赖（spring-boot-starter和spring-boot-autoconfigure）。
创建配置属性类。
创建自动配置类。
添加META-INF/spring.factories文件来声明自动配置类。
打包并发布到Maven仓库或私有仓库。

示例代码：




<!-- pom.xml -->
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-autoconfigure</artifactId>
    </dependency>
</dependencies>




// MyAutoConfiguration.java
@Configuration
@ConditionalOnClass(MyService.class)
@EnableConfigurationProperties(MyProperties.class)
public class MyAutoConfiguration {
 
    @Autowired
    private MyProperties properties;
 
    @Bean
    @ConditionalOnMissingBean
    public MyService myService() {
        return new MyService(properties.getSomeProperty());
    }
}




# META-INF/spring.factories
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.example.MyAutoConfiguration