分类后端技术下的文章

Java之 Spring Cloud 微服务的链路追踪 Sleuth 和 Zipkin（第三个阶段）

2024-08-29

在Spring Cloud微服务架构中，链路追踪可以帮助我们理解请求在系统中的流动情况，Sleuth和Zipkin是实现这一功能的两个重要组件。以下是如何将Sleuth和Zipkin集成到Spring Cloud微服务中的代码示例。

在Spring Cloud微服务的pom.xml中添加Sleuth和Zipkin的依赖：




<!-- Spring Cloud Sleuth -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-sleuth</artifactId>
</dependency>
<!-- Zipkin Server -->
<dependency>
    <groupId>io.zipkin.java</groupId>
    <artifactId>zipkin-server</artifactId>
</dependency>
<!-- Zipkin Client for Sleuth -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-sleuth-zipkin</artifactId>
</dependency>

启动Zipkin Server。可以使用Spring Cloud提供的已经配置好的Zipkin Server，也可以自己搭建。




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

在微服务应用的配置文件application.properties中指定Zipkin Server的URL：




spring.zipkin.base-url=http://localhost:9411
spring.sleuth.sampler.probability=1.0 # 设置为1.0表示记录所有请求的追踪信息，生产环境可以根据需要调整采样率

微服务应用现在可以将追踪信息发送到Zipkin Server，并且可以通过Zipkin UI查看服务间调用的追踪信息。

以上步骤展示了如何在Spring Cloud微服务中集成Sleuth和Zipkin。开发者可以根据自己的实际情况进行调整，例如更改采样率来降低生产环境的性能开销。

- 阅读更多 -

postgre sql 将非分区表转化为分区表，动态创建和删除分区

System

2024-08-29

所有,数据库

在PostgreSQL中，将非分区表转换为分区表通常涉及创建一个分区键，然后根据这个键动态地创建分区。以下是一个简化的例子，展示了如何实现这一过程：




-- 假设有一个非分区表
CREATE TABLE measurement (
    city_id         int not null,
    logdate         date not null,
    peaktemp        int,
    unitsales       int
);
 
-- 添加分区键 (在这个例子中，我们将按照日期进行分区)
ALTER TABLE measurement SET TABLESPACE pg_default;
 
-- 创建分区主表
CREATE TABLE measurement_data (LIKE measurement INCLUDING ALL) PARTITION BY RANGE (logdate);
 
-- 动态创建分区的函数
CREATE OR REPLACE FUNCTION create_partitions(start_date date, end_date date) RETURNS void AS $$
DECLARE
    current_date date := start_date;
BEGIN
    WHILE current_date <= end_date LOOP
        EXECUTE format('CREATE TABLE measurement_data_%s PARTITION OF measurement_data FOR VALUES (%L) TABLESPACE pg_default', 
                        to_char(current_date, 'YYYY-MM-DD'), current_date);
        current_date := current_date + '1 day'::interval;
    END LOOP;
END;
$$ LANGUAGE plpgsql;
 
-- 调用函数创建分区，例如从2020-01-01到2020-12-31
SELECT create_partitions('2020-01-01'::date, '2020-12-31'::date);
 
-- 动态删除分区的函数
CREATE OR REPLACE FUNCTION drop_partitions() RETURNS void AS $$
DECLARE
    current_date date := '2020-01-01';
BEGIN
    WHILE current_date <= '2020-12-31' LOOP
        EXECUTE format('DROP TABLE measurement_data_%s', to_char(current_date, 'YYYY-MM-DD'));
        current_date := current_date + '1 day'::interval;
    END LOOP;
END;
$$ LANGUAGE plpgsql;
 
-- 调用函数删除分区
SELECT drop_partitions();

在这个例子中，我们首先创建了一个非分区表measurement。然后，我们创建了一个分区主表measurement_data，并指定了分区键为logdate。接着，我们定义了两个函数：create_partitions和drop_partitions，这些函数可以动态地创建和删除分区。create_partitions函数接受一个开始日期和结束日期，然后为每一天创建一个分区。drop_partitions函数则会删除所有这些分区。

注意：在实际环境中，你可能需要更复杂的逻辑来处理分区的创建和删除，例如确保分区的范围和数量是合理的，或者处理数据文件的存储和分区表的维护。

- 阅读更多 -

基于Spring Boot的航班调度系统的设计与实现

System

2024-08-29

所有,java

由于原始代码较为复杂且涉及多个类和接口，我们将提供关键组件的简化版本。




// FlightService.java
import org.springframework.stereotype.Service;
import java.util.List;
 
@Service
public class FlightService {
    public List<Flight> getAllFlights() {
        // 实现获取所有航班信息的逻辑
        return null; // 示例代码，实际应返回航班列表
    }
 
    public Flight getFlightById(Long id) {
        // 实现通过ID获取特定航班信息的逻辑
        return null; // 示例代码，实际应返回Flight对象
    }
 
    public Flight createFlight(Flight flight) {
        // 实现创建新航班信息的逻辑
        return null; // 示例代码，实际应返回Flight对象
    }
 
    public Flight updateFlight(Long id, Flight flight) {
        // 实现更新航班信息的逻辑
        return null; // 示例代码，实际应返回Flight对象
    }
 
    public void deleteFlightById(Long id) {
        // 实现通过ID删除航班信息的逻辑
    }
}

在这个简化版本中，我们定义了一个名为FlightService的服务类，它包含了管理航班信息所需的基本CRUD操作。这个类被标记为@Service注解，表明它是Spring的服务组件，并且可以自动注入到Spring容器中。

请注意，示例代码中的方法实现是模拟的，实际应用中需要根据具体的数据库操作来实现这些方法的逻辑。

- 阅读更多 -

Redis~从RDBMS(关系型数据库管理系统)到Nosql(非关系型数据库)

System

2024-08-29

所有,redis

在上一部分中，我们讨论了Redis的基本数据类型和它的内存存储特性。在这一部分，我们将讨论Redis的持久化特性和复制特性。

Redis的持久化主要有两种方式：RDB（Redis DataBase）和AOF（Append Only File）。

RDB：定时将内存中的数据快照保存到磁盘的一个压缩二进制文件中。可以配置定时任务来完成此操作。




# 配置文件中的例子
save 900 1      # 900秒内至少1个键被修改则触发保存
save 300 10     # 300秒内至少10个键被修改则触发保存
save 60 10000   # 60秒内至少10000个键被修改则触发保存

AOF：每个写命令都通过append操作保存到文件中。在服务重启时，通过重放这些命令来恢复数据。




# 配置文件中的例子
appendonly yes       # 开启AOF
appendfsync everysec # 每秒同步一次至磁盘

Redis的复制特性允许将一个Redis服务器的数据复制到其他服务器。这是实现Redis高可用和分布式的基础。




# 配置文件中的例子
slaveof <master-ip> <master-port> # 设置当前实例为某个主实例的从实例

在实际应用中，可以根据数据的重要性和性能需求，选择合适的持久化方式，或者将两者结合使用。同时，可以通过Redis的Sentinel或者Cluster功能来管理和维护Redis的高可用和分布式环境。

- 阅读更多 -

Oracle可刷新克隆PDB

System

2024-08-29

所有,数据库

在Oracle数据库中，可刷新克隆（refresh-clone）是指你可以通过使用DBMS\_PDB包中的程序来更新克隆的可插拔数据库（PDB）以反映源PDB中的更改。这通常用于维护一个次要的只读副本，同时允许对源PDB进行更改。

要刷新一个克隆的PDB以反映源PDB的更新，你可以使用以下步骤：

确保源PDB和目标克隆PDB处于相同的软件版本。
确保目标克隆PDB处于装载状态。
使用DBMS_PDB包中的DESCRIBE过程来获取源PDB的更新信息。
使用REFRESH_CLONE过程来应用这些更新。

以下是一个简单的PL/SQL代码示例，展示如何刷新一个克隆的PDB：




-- 假设源PDB是source_pdb.example.com，克隆PDB是clone_pdb
 
-- 1. 首先打开源PDB
ALTER PLUGGABLE DATABASE source_pdb OPEN;
 
-- 2. 获取克隆PDB的描述信息
DECLARE
  clone_info SYS.KU$_PDB_CLONE_INFO;
BEGIN
  DBMS_PDB.DESCRIBE(pdb_descr_file => 'clone_pdb_desc.txt', pdb_name => 'clone_pdb');
END;
/
 
-- 3. 装载克隆PDB
ALTER PLUGGABLE DATABASE clone_pdb SAVE STATE;
 
-- 4. 刷新克隆PDB以反映源PDB的更新
BEGIN
  DBMS_PDB.REFRESH_CLONE(
    source_pdb      => 'source_pdb.example.com',
    clone_pdb       => 'clone_pdb',
    pdb_descr_file  => 'clone_pdb_desc.txt'
  );
END;
/
 
-- 5. 打开克隆PDB并使其可用
ALTER PLUGGABLE DATABASE clone_pdb OPEN;

确保在执行这些操作之前，你有适当的权限，并且在操作之前已经做了适当的备份。如果你的克隆PDB有任何自定义或特殊的配置，你可能需要在刷新之前进行适当的处理。

- 阅读更多 -

Spring Boot中的模板引擎选择与配置

System

2024-08-29

所有,java

在Spring Boot中，你可以选择多种模板引擎，如Thymeleaf、FreeMarker、Mustache等。以下是一个使用Thymeleaf的配置示例：

在pom.xml中添加Thymeleaf依赖：




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

在application.properties或application.yml中配置Thymeleaf模板引擎设置（可选）：




# application.properties 示例
spring.thymeleaf.prefix=classpath:/templates/
spring.thymeleaf.suffix=.html
spring.thymeleaf.mode=HTML5
spring.thymeleaf.encoding=UTF-8
spring.thymeleaf.content-type=text/html

或者使用YAML格式：




# application.yml 示例
spring:
  thymeleaf:
    prefix: classpath:/templates/
    suffix: .html
    mode: HTML5
    encoding: UTF-8
    content-type: text/html

创建一个Controller来使用Thymeleaf模板：




import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
 
@Controller
public class MyController {
 
    @GetMapping("/greeting")
    public String greeting(Model model) {
        model.addAttribute("name", "World");
        return "greeting"; // 对应src/main/resources/templates/greeting.html
    }
}

在src/main/resources/templates目录下创建一个名为greeting.html的Thymeleaf模板文件：




<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Greeting</title>
</head>
<body>
    <h1 th:text="'Hello, ' + ${name} + '!'">Hello, World!</h1>
</body>
</html>

以上示例展示了如何在Spring Boot项目中集成Thymeleaf模板引擎，并通过一个简单的Controller返回渲染后的视图。

- 阅读更多 -

MyBatis与Spring和Spring Boot的整合

System

2024-08-29

所有,java

整合Spring和Spring Boot的MyBatis配置步骤大致如下：

引入依赖：
- 在Spring Boot项目的pom.xml中添加MyBatis和数据库驱动的依赖。




<dependencies>
    <!-- Spring Boot相关依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- MyBatis依赖 -->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.1.3</version>
    </dependency>
    <!-- 数据库驱动，以MySQL为例 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>
</dependencies>

配置数据源和MyBatis：
- 在application.properties或application.yml中配置数据源和MyBatis的mapper文件位置。




# application.properties
spring.datasource.url=jdbc:mysql://localhost:3306/your_database?useSSL=false
spring.datasource.username=root
spring.datasource.password=yourpassword
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
 
mybatis.mapper-locations=classpath:mapper/*.xml
mybatis.type-aliases-package=com.yourpackage.model

创建Mapper接口和Mapper XML文件：
- 在Java包中创建Mapper接口。
- 在resources的mapper目录下创建对应的XML文件。




// UserMapper.java
package com.yourpackage.mapper;
 
public interface UserMapper {
    User selectUserById(int id);
}




<!-- UserMapper.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yourpackage.mapper.UserMapper">
    <select id="selectUserById" parameterType="int" resultType="com.yourpackage.model.User">
        SELECT * FROM users WHERE id = #{id}
    </select>
</mapper>

使用Mapper：
- 在Service层通过注入Mapper接口，使用其方法。




// UserService.java
package com.yourpackage.service;
 
import com.yourpackage.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;
 
    public User getUserById(int id) {
        return userMapper.selectUserById(id);
    }
}

以上步骤可以使你的MyBatis与Spring或Spring Boot项目整合起来，并能在Service层使用Mapper接口进行数据库操作。

- 阅读更多 -

03 前后端数据交互【小白入门SpringBoot + Vue3】

System

2024-08-29

所有,java

在Spring Boot和Vue.js之间进行数据交互，通常是通过REST API进行的。以下是一个简单的例子，展示了如何在Spring Boot后端创建一个REST API，并在Vue.js前端中调用它。

Spring Boot后端:

创建一个REST控制器:




@RestController
@RequestMapping("/api/items")
public class ItemController {
 
    // 假设有一个服务层，这里省略了服务层的实现
 
    @GetMapping
    public ResponseEntity<List<Item>> getAllItems() {
        // 获取所有项目的逻辑
        List<Item> items = // ... 获取数据的逻辑
        return ResponseEntity.ok(items);
    }
}

Vue.js前端:

安装axios:




npm install axios

在Vue组件中使用axios发送请求并处理响应:




<template>
  <div>
    <ul>
      <li v-for="item in items" :key="item.id">{{ item.name }}</li>
    </ul>
  </div>
</template>
 
<script>
import axios from 'axios';
 
export default {
  data() {
    return {
      items: []
    };
  },
  created() {
    this.fetchItems();
  },
  methods: {
    async fetchItems() {
      try {
        const response = await axios.get('http://localhost:8080/api/items');
        this.items = response.data;
      } catch (error) {
        console.error('An error occurred while fetching items:', error);
      }
    }
  }
};
</script>

在这个例子中，Spring Boot后端暴露了一个/api/items的端点，Vue.js前端通过axios在created钩子函数中异步请求这个端点，并将返回的数据存储在本地数据属性items中，然后可以在模板中进行渲染。

- 阅读更多 -

关于“Python”的核心知识点整理大全56

System

2024-08-29

所有,数据库

在Python中，有一些核心的概念和特性，我们可以将它们概括为一些关键点。以下是一些常见的Python核心知识点：

变量与数据类型
控制流：条件语句（if, for, while）
函数：定义和使用
类与对象：定义和使用
模块：导入和使用
异常处理：try-except
迭代器与生成器
装饰器：装饰函数
列表推导式与字典推导式
文件操作：open, with
高阶函数：map, reduce, filter
面向对象编程特性：继承、多态、封装
异步I/O：asyncio模块
异步编程：async/await
异步上下文管理器：async with
异步生成器：async for
异步任务创建：asyncio.create\_task
异步事件循环：asyncio.run
异步锁：asyncio.Lock
异步信号量：asyncio.Semaphore
异步队列：asyncio.Queue
异步生产者-消费者模型
正则表达式：re模块
JSON处理：json模块
日期和时间：datetime模块
时间序列操作：pandas模块
数据库操作：sqlite3模块
网络编程：socket模块
网络请求：requests模块
异步网络请求：aiohttp模块
异步Web框架：Starlette/FastAPI
异步数据库：Tortoise ORM
异步任务队列：Celery
异步视图：aiohttp模板
异步GraphQL：graphql-core-next
异步GraphQL框架：strawberry-graphql
异步GraphQL服务器：starlette-graphql
异步GraphQL客户端：gql-alchemy
异步WebSocket：starlette WebSocket
异步任务调度：apscheduler
异步并发限制：asyncio.Semaphore
异步IO操作：asyncio.run
异步上下文管理器：async with
异步锁：asyncio.Lock
异步信号量：asyncio.Semaphore
异步队列：asyncio.Queue
异步事件循环：asyncio.run
异步任务创建：asyncio.create\_task
异步编程：async/await
异步上下文管理器：async with
异步生成器：async for
异步锁：asyncio.Lock
异步信号量：asyncio.Semaphore
异步队列：asyncio.Queue
异步事件循环：asyncio.run
异步任务创建：asyncio.create\_task

这些是Python的核心概念，每个概念都是学习Python的基石，并且在实际开发中经常使用。理解这些概念并掌握相关用法，将有助于你更好地进行Python开发。

System

2024-08-29

所有,java

Spring Cloud Alibaba Nacos 是一套简单易用的服务发现和配置管理的组件，可以帮助我们更好的实现微服务的构建。

服务注册与发现

Spring Cloud Alibaba Nacos 可以让我们的微服务与 Nacos 注册中心之间进行无缝对接，使得服务之间可以通过 Nacos 进行相互定位和通信。

以下是一个简单的示例，演示如何在 Spring Cloud 应用中使用 Nacos 作为服务注册中心：




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

在 application.properties 或 application.yml 文件中配置 Nacos 服务器地址：




spring.cloud.nacos.discovery.server-addr=127.0.0.1:8848

配置管理

Nacos 提供了一个配置中心，我们可以在 Nacos 中管理所有的配置文件，并且可以实时的推送到客户端。

以下是一个示例，演示如何在 Spring Cloud 应用中使用 Nacos 作为配置中心：




@Configuration
@EnableConfigurationProperties
@NacosPropertySource(dataId = "example", groupId = "DEFAULT_GROUP")
public class NacosConfig {
    @NacosValue(value = "${useLocalCache:false}", autoRefreshed = true)
    private boolean useLocalCache;
}

在 application.properties 或 application.yml 文件中配置 Nacos 服务器地址和需要加载的配置信息：




spring.cloud.nacos.config.server-addr=127.0.0.1:8848
spring.cloud.nacos.config.namespace=8848
spring.cloud.nacos.config.group=DEFAULT_GROUP
spring.cloud.nacos.config.extension-configs[0].data-id=example.properties
spring.cloud.nacos.config.extension-configs[0].group=DEFAULT_GROUP
spring.cloud.nacos.config.extension-configs[0].refresh=true

以上代码展示了如何在 Spring Cloud 应用中使用 Nacos 作为配置管理，并且如何从 Nacos 中读取配置信息。

- 阅读更多 -