Tech Blog

2024-09-03

所有,数据库

MongoDB是一个基于分布式文件存储的开源数据库系统，旨在为WEB应用提供高性能、易部署、易使用、存储高效的数据存储解决方案。

基本概念

数据库(database)：MongoDB中数据库的概念和关系型数据库中的数据库概念类似，一个MongoDB实例可以有多个数据库，每个数据库有独立的集合(collection)。
集合(collection)：数据库的一组记录，类似于关系型数据库中的表。
文档(document)：一个键值对(key-value)构成的数据，相当于关系型数据库中的一行记录。
元数据：每个文档都有一个_id字段作为主键，用于唯一标识文档。

常用操作

连接数据库：在Node.js环境中，可以使用mongodb模块来连接MongoDB数据库。




const MongoClient = require('mongodb').MongoClient;
const url = 'mongodb://localhost:27017';
 
MongoClient.connect(url, function(err, client) {
  if (err) throw err;
  console.log("数据库连接成功！");
  const db = client.db('mydatabase');
  client.close();
});

插入文档：使用insertOne或insertMany方法插入文档到集合中。




const MongoClient = require('mongodb').MongoClient;
const url = 'mongodb://localhost:27017';
 
MongoClient.connect(url, function(err, client) {
  if (err) throw err;
  const db = client.db('mydatabase');
  const collection = db.collection('documents');
  collection.insertOne({a: 1}, function(err, result) {
    if (err) throw err;
    console.log("文档插入成功");
    client.close();
  });
});

查询文档：使用find或findOne方法查询集合中的文档。




const MongoClient = require('mongodb').MongoClient;
const url = 'mongodb://localhost:27017';
 
MongoClient.connect(url, function(err, client) {
  if (err) throw err;
  const db = client.db('mydatabase');
  const collection = db.collection('documents');
  collection.findOne({a: 1}, function(err, document) {
    if (err) throw err;
    console.log(document);
    client.close();
  });
});

更新文档：使用updateOne或updateMany方法更新集合中的文档。




const MongoClient = require('mongodb').MongoClient;
const url = 'mongodb://localhost:27017';
 
MongoClient.connect(url, function(err, client) {
  if (err) throw err;
  const db = client.db('mydatabase');
  const collection = db.collection('documents');
  collection.updateOne({a: 1}, {$set: {b: 1}}, function(err, result) {
    if (err) throw err;
    console.log("文档更新成功");
    client.close();
  });
});

删除文档：使用deleteOne或deleteMany方法删除集合中的文档。




const MongoClient = require('mongodb').MongoClient;
const url = 'mongodb://localhost:27017';
 
MongoClient.connect(url, function(err, client) {
  if (err) throw err;
  const db = client.db('mydatabase');
  const collectio

postgresql设置自动更新时间戳解决办法

2024-09-03

所有,数据库

在PostgreSQL中，可以使用CREATE TRIGGER语句来创建一个触发器，以自动更新时间戳字段。以下是一个如何设置触发器来自动更新时间戳的例子：

首先，创建一个表，其中包含一个用于自动更新的时间戳字段：




CREATE TABLE example_table (
    id SERIAL PRIMARY KEY,
    data JSONB,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

然后，创建一个触发器来在每次更新操作时更新updated_at字段：




CREATE FUNCTION update_timestamp() RETURNS TRIGGER AS $$
BEGIN
    NEW.updated_at = CURRENT_TIMESTAMP;
    RETURN NEW;
END;
$$ LANGUAGE plpgsql;
 
CREATE TRIGGER update_example_table_timestamp
    BEFORE UPDATE ON example_table
    FOR EACH ROW EXECUTE FUNCTION update_timestamp();

现在，每当对example_table表进行更新操作时，updated_at字段都会自动更新为当前时间戳。

Golang math.bits 包详解

2024-09-03

所有,golang

math/bits 包提供了处理整数作为位序列的函数。这个包在Go 1.9版本引入。这个包中的函数主要用于处理无符号整数的位操作。

以下是math/bits包中的一些常用函数：

Len：返回x在二进制表示下的位数。
OnesCount：返回x在二进制表示下1的个数。
LeadingZeros：返回x最高非零位前导的零位的数量。
TrailingZeros：返回x最低非零位后的零位的数量。
RotateLeft：将x左旋转k位。
RotateRight：将x右旋转k位。
Reverse：返回x的二进制表示的按位反转。
Sub：计算x - y，结果以uint类型数组返回。
Add：计算x + y + carry，结果以uint类型数组返回。
Mul：计算x * y，结果以uint类型数组返回。
Div：计算x / y，结果以uint类型数组返回。
Rem：计算x % y。
Le：如果x <= y，返回真。
Lt：如果x < y，返回真。
Ge：如果x >= y，返回真。
Gt：如果x > y，返回真。
TrailingZeros64：返回x最低非零位后的零位的数量。
OnesCount64：返回x在二进制表示下1的个数。
Len64：返回x在二进制表示下的位数。
Reverse64：返回x的二进制表示的按位反转。
ReverseBytes：返回x的字节顺序翻转。
ReverseBytes64：返回x的字节顺序翻转。

以下是一些使用这些函数的示例代码：




package main
 
import (
    "fmt"
    "math/bits"
)
 
func main() {
    x := uint(45)
    fmt.Println("Len:", bits.Len(x))
    fmt.Println("OnesCount:", bits.OnesCount(x))
    fmt.Println("LeadingZeros:", bits.LeadingZeros(x))
    fmt.Println("TrailingZeros:", bits.TrailingZeros(x))
    fmt.Println("RotateLeft:", bits.RotateLeft(x, 2))
    fmt.Println("RotateRight:", bits.RotateRight(x, 2))
    fmt.Println("Reverse:", bits.Reverse(x))
    y := uint(12)
    fmt.Println("Sub:", bits.Sub(x, y))
    fmt.Println("Add:", bits.Add(x, y, 0))
    fmt.Println("Mul:", bits.Mul(x, y))
    fmt.Println("Div:", bits.Div(x, y))
    fmt.Println("Rem:", bits.Rem(x, y))
    fmt.Println("Le:", bits.Le(x, y))
    fmt.Println("Lt:", bits.Lt(x, y))
    fmt.Println("Ge:", bits.Ge(x, y))
    fmt.Println("Gt:", bits.Gt(x, y))
}

这个代码片段演示了如何使用math/bits包中的一些基本函数。这个包提供的函

[Spring Cloud] gateway全局异常捕捉统一返回值

2024-09-03

在Spring Cloud Gateway中，可以通过定义一个全局过滤器来捕捉异常，并返回统一的响应格式。以下是一个简单的实现示例：




import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.io.buffer.DataBufferUtils;
import org.springframework.core.io.buffer.NettyDataBufferFactory;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
 
import java.nio.charset.StandardCharsets;
 
public class GlobalExceptionHandlerFilter implements GlobalFilter {
 
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        return chain.filter(exchange).onErrorResume((throwable) -> {
            ServerHttpResponse response = exchange.getResponse();
            // 设置响应状态码
            response.setStatusCode(HttpStatus.INTERNAL_SERVER_ERROR);
            // 设置响应头
            response.getHeaders().set("Content-Type", "application/json");
 
            // 创建返回的统一结果对象
            String errorResult = "{\"code\": 500, \"message\": \"系统异常，请联系管理员\"}";
            // 返回统一结果
            DataBufferUtils.write(response.bufferFactory(), errorResult, new NettyDataBufferFactory(ByteBufAllocator.DEFAULT))
                    .doOnError(err -> DataBufferUtils.release(response.getBody()))
                    .doOnTerminate(() -> response.close());
 
            return Mono.empty();
        });
    }
}

然后需要将这个全局过滤器注册到Spring Cloud Gateway中：




import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
@Configuration
public class GatewayConfig {
 
    @Bean
    public GlobalExceptionHandlerFilter globalExceptionHandlerFilter() {
        return new GlobalExceptionHandlerFilter();
    }
}

这样配置后，当GatewayFilterChain中的过滤器链发生异常时，GlobalExceptionHandlerFilter将会捕捉到异常，并返回统一的JSON格式的错误信息。

Flink-DataWorks第三部分：数据集成（第59天）

2024-09-03

所有,php

在Flink DataWorks中，数据集成通常指的是将不同数据源的数据导入到Flink DataStream中进行处理。以下是使用Flink DataStream API进行数据集成的一个简单示例：




import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer;
 
import java.util.Properties;
 
public class FlinkKafkaConsumerExample {
 
    public static void main(String[] args) throws Exception {
        final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
 
        Properties properties = new Properties();
        properties.setProperty("bootstrap.servers", "localhost:9092");
        properties.setProperty("group.id", "test");
        properties.setProperty("auto.offset.reset", "earliest");
 
        DataStream<String> stream = env
            .addSource(new FlinkKafkaConsumer<>(
                "test",            // topic name
                new SimpleStringSchema(),  // deserialization schema
                properties));     // consumer properties
 
        // 进行数据处理
        stream.print();
 
        env.execute("Flink Kafka Consumer Example");
    }
}

在这个例子中，我们使用了Flink的Kafka连接器从名为"test"的Kafka主题中读取数据。我们首先配置了一个Properties对象来设置Kafka消费者所需的基本属性，如bootstrap服务器地址和消费者组ID。然后，我们创建了一个FlinkKafkaConsumer实例，指定了主题名、数据反序列化方式和之前配置的属性。最后，我们将这个Kafka源添加到Flink的数据流中，并打印出数据流以进行处理。

请注意，这只是一个简单的示例，实际使用时需要根据具体的数据源和处理需求进行相应的调整。

微服务入门（Nacos,Feign,网关Zuul）

2024-09-03

微服务是一种架构风格，它将单一应用程序拆分成一组小型服务，每个服务运行在自己的进程中，服务之间通过轻量级的通信机制互相协作。

Nacos是一个更易于构建云原生应用的动态服务发现、配置和服务管理平台。

Feign是一个声明式的Web服务客户端，它使得编写Web服务客户端变得更加简单。

Zuul是Netflix开源的API路由和服务网关，提供动态路由、监控、弹性负载均衡等功能。

以下是一个简单的示例，演示如何使用Nacos作为服务注册中心，Feign进行服务间调用，以及Zuul作为API网关。

引入相关依赖（Maven示例）：




<!-- Nacos客户端依赖 -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<!-- Feign客户端依赖 -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
<!-- Zuul路由网关依赖 -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
</dependency>

配置application.properties或者application.yml文件：




spring:
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848 # Nacos服务器地址
 
server:
  port: 8080
 
feign:
  hystrix:
    enabled: true # 开启Feign的熔断功能
 
zuul:
  routes:
    user-service: # 路由ID，可以自定义
      path: /user-service/** # 匹配路径
      serviceId: user-service # 对应的服务ID

启动类添加注解：




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

Feign客户端调用示例：




@FeignClient(name = "user-service", fallback = UserServiceFallback.class)
public interface UserServiceClient {
    @GetMapping("/users/{id}")
    UserDto getUserById(@PathVariable("id") Long id);
}
 
@Component
public class UserServiceFallback implements UserServiceClient {
    @Override
    public UserDto getUserById(Long id) {
        return new UserDto("Error", "Error");
    }
}

启动Nacos服务，启动微服务，启动网关服务。

以上示例展示了如何将Nacos作为服务注册中心，Feign用于服务间的调用，以及Zuul作为API网关的简单使用。这些组件结合使用可以帮助开发者构建一个健壮的微服务架构。

spring boot actuator 安全配置 springboot的安全性

2024-09-03

在Spring Boot中，你可以通过配置文件来保护Actuator端点的安全性。以下是一个配置示例，使用Spring Security来保护Actuator端点：

首先，确保你的项目中包含了Spring Security依赖。




<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

在application.properties或application.yml中配置Actuator的安全性。




# application.properties
management.endpoints.web.exposure.include=health,info,prometheus
management.endpoint.health.show-details=always
 
# 用户名和密码
security.user.name=admin
security.user.password=admin

配置Spring Security以保护Actuator端点。




import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
 
@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
 
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .requestMatchers(EndpointRequest.toAnyEndpoint()).authenticated()
                .anyRequest().permitAll()
            .and()
            .httpBasic();
    }
 
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth
            .inMemoryAuthentication()
                .withUser("admin").password("{noop}admin").roles("USER");
    }
}

在上述配置中，我们：

通过management.endpoints.web.exposure.include指定了需要暴露的Actuator端点。
使用HttpSecurity配置了Spring Security，要求对Actuator端点的访问需要认证，并使用基本认证。
通过AuthenticationManagerBuilder配置了内存中的用户名和密码。

请注意，在生产环境中，你应该使用更安全的方式来存储用户凭据，例如使用数据库或者其他认证服务。同时，你可以根据需要进一步自定义安全策略，比如使用角色来限制不同用户对不同端点的访问权限。

SpringBoot项目部署到Tomcat

2024-09-03

在Spring Boot项目中，通常我们会打包成一个可以直接运行的jar文件，然后通过java -jar命令来启动。但如果你需要将其部署到Tomcat中，你需要做一些额外的步骤。

确保你的Spring Boot项目中的pom.xml文件没有包含Tomcat插件，因为Spring Boot已经内置了Tomcat。
将项目打包成war文件而不是jar文件。你需要修改pom.xml文件来实现这一点：




<packaging>war</packaging>

继承SpringBootServletInitializer并重写configure方法：




import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
 
@SpringBootApplication
public class YourApplication extends SpringBootServletInitializer {
 
    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
        return application.sources(YourApplication.class);
    }
 
    public static void main(String[] args) throws Exception {
        SpringApplication.run(YourApplication.class, args);
    }
}

完成这些步骤后，使用mvn clean package命令打包你的项目，这会生成一个.war文件。
将生成的.war文件部署到Tomcat服务器中，并启动Tomcat。

注意：Spring Boot版本更新较快，如果你使用的是Spring Boot 2.0及以上版本，你需要在pom.xml中添加以下依赖来支持WAR包的生成：




<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

确保你的Tomcat版本与Spring Boot兼容。

URL路由基础与Django处理请求的过程分析

2024-09-03

所有,数据库




from django.http import HttpResponse
from django.urls import path
from . import views
 
urlpatterns = [
    path('articles/2003/', views.special_case_2003),
    path('articles/<int:year>/', views.year_archive),
    path('articles/<int:year>/<int:month>/', views.month_archive),
    path('articles/<int:year>/<int:month>/<slug:slug>/', views.article_detail),
]
 
# 以下是对应的views.py文件中的函数示例
 
def special_case_2003(request):
    return HttpResponse("2003年的特殊案例")
 
def year_archive(request, year):
    return HttpResponse(f"{year}年的档案")
 
def month_archive(request, year, month):
    return HttpResponse(f"{year}-{month}月的档案")
 
def article_detail(request, year, month, slug):
    return HttpResponse(f"文章详情：{year}-{month}-{slug}")

这个示例代码展示了如何在Django中定义URL路由以及如何在对应的视图函数中处理请求。代码中的path函数用于定义单个路由，每个路由都指定了匹配模式和对应的视图函数。视图函数负责处理与用户的交互，并返回响应内容。

tomcat的原理与安装过程

2024-09-03

Tomcat是一个开源的Java Servlet容器，用于运行Java Web应用程序。以下是Tomcat的基本原理和安装步骤：

原理：

Tomcat由一系列服务（如Web服务器、连接器和容器）组成。
Web服务器用于处理HTTP请求。
连接器将Servlet容器和Web服务器连接起来。
容器是一个Servlet实例的运行环境，负责管理Servlet的生命周期和用户请求。

安装Tomcat：

下载Tomcat：访问Apache Tomcat官网（https://tomcat.apache.org/）下载相应版本的Tomcat。
安装Tomcat：解压下载的压缩包到指定目录。
配置环境变量：设置CATALINA_HOME指向Tomcat安装目录，并确保JAVA_HOME已正确设置。
启动Tomcat：运行$CATALINA_HOME/bin目录下的启动脚本（如startup.sh或startup.bat）。
测试Tomcat：在浏览器中访问http://localhost:8080，如果看到Tomcat的欢迎页面，则表示安装成功。

注意：具体步骤可能因操作系统或Tomcat版本略有不同。