反向/正向代理

在 IT 行业中, 反向代理(Reverse Proxy)是一种网络代理服务器的配置方式, 它充当了服务器和客户端之间的中间人。与传统的正向代理(Forward Proxy)不同, 正向代理是为客户端提供代理服务, 而反向代理是为服务器提供代理服务。 可以参考nginx (opens new window)以查看更多

反向代理的工作原理是将客户端的请求转发到后端服务器, 并将服务器的响应返回给客户端。客户端发送请求时, 先与反向代理建立连接, 然后反向代理根据配置的规则将请求转发到后端的真实服务器上。后端服务器处理请求并返回响应, 然后反向代理将响应返回给客户端, 客户端则认为响应是直接来自于反向代理

---

反向代理的主要作用有以下几个方面:

1. 负载均衡: 反向代理可以根据预设的负载均衡算法将客户端请求分发到多个后端服务器, 从而平衡服务器的负载, 提高系统的性能和可靠性
2. 缓存静态内容: 反向代理可以缓存静态资源, 如图片、CSS 文件等, 以减轻后端服务器的负担, 提高响应速度
3. SSL/TLS 加密: 反向代理可以作为 SSL/TLS 终端, 将客户端的 HTTPS 请求转发给后端服务器, 并将响应返回给客户端, 实现对传输内容的加密和安全性保护
4. 安全过滤: 反向代理可以对传入的请求进行安全过滤和防御, 例如阻止恶意请求、DDoS 攻击和 Web 应用程序漏洞等

通过使用反向代理, 可以提高网络应用的可扩展性、安全性和性能, 同时为系统管理员提供了更好的控制和管理手段

wlan0

"wlan0"是指在 Android 设备上表示无线局域网(Wi-Fi)接口的网络接口名称。在大多数 Android 设备中, 无线网络接口通常被标识为"wlan0", 但也有一些设备可能使用其他名称, 如"wlan1"、"wlan2"等, 这取决于设备的硬件和配置

通过"wlan0"网络接口, Android 设备可以连接到 Wi-Fi 网络并进行无线通信。它负责处理与 Wi-Fi 相关的功能, 包括扫描可用网络、建立连接、传输数据等

使用命令adb shell ip address show wlan"可以查看设备上"wlan0"接口的 IP 地址信息。这样可以获取设备当前连接的 Wi-Fi 网络的 IP 地址, 以及其他相关的网络配置信息

DevOps

DevOps 是一种软件开发和运维的实践方法, 旨在通过加强开发团队和运维团队之间的协作和沟通, 实现快速、可靠的软件交付和部署

DevOps 的目标是通过自动化、持续集成和持续交付等实践, 将软件开发、测试、部署和运维的过程整合起来, 从而加快软件的交付速度、提高质量, 并增强系统的稳定性和可扩展性

DevOps 强调以下几个关键概念和实践:

1. 自动化: 通过自动化工具和流程, 减少人工操作, 提高效率和一致性
2. 持续集成: 将代码频繁地集成到共享的代码库中, 通过自动化构建、测试和静态代码分析等环节, 确保代码质量和稳定性
3. 持续交付: 在持续集成的基础上, 将软件交付到生产环境中, 实现快速的软件发布和部署
4. 基础设施即代码: 使用代码和自动化工具来管理和配置基础设施, 以便快速、可靠地创建、部署和管理基础设施资源
5. 监控和日志: 通过实时监控和日志记录, 及时发现和解决系统问题, 提高系统的可用性和性能
6. 跨团队协作: 强调开发团队和运维团队之间的协作和沟通, 打破组织内的隔阂, 促进快速响应和问题解决

DevOps 的目标是通过整合开发和运维流程, 加强团队协作, 实现更高效、更可靠的软件交付和运维。它可以帮助组织更快速地响应市场需求、降低软件交付的风险和成本, 并提供更好的用户体验

数据库系统

MongoDB、Redis 和关系型数据库是常见的数据库系统, 它们在数据存储和访问方面具有不同的特点和适用场景

MongoDB、Redis 和关系型数据库是常见的数据库系统, 它们在数据存储和访问方面具有不同的特点和适用场景

1. 关系型数据库(如 MySQL、PostgreSQL):

• 结构化数据存储: 关系型数据库使用表格(表)来组织和存储数据, 数据以行和列的形式呈现, 并且需要定义表的结构(模式)
• 强一致性: 关系型数据库提供强一致性, 即数据的读取和写入操作是同步和可靠的
• SQL 查询语言: 关系型数据库使用 SQL(Structured Query Language)进行数据查询和操作
• 适用场景: 适合存储结构化数据, 如订单、用户信息等, 并需要进行复杂的事务处理和关系查询

2. MongoDB:

• 非结构化数据存储: MongoDB 是一种面向文档的数据库, 数据以类似 JSON 的 BSON 格式存储, 不需要预定义模式, 可以灵活地存储非结构化数据
• 高可扩展性: MongoDB 支持水平扩展, 可以轻松处理大规模数据和高并发请求
• 分布式数据库: MongoDB 可以作为分布式数据库, 通过副本集和分片技术实现数据的冗余备份和水平切分
• 适用场景: 适合存储大量非结构化数据, 如日志、用户行为记录等, 并需要灵活性和可扩展性

3. Redis:

• 键值存储: Redis 是一种键值存储数据库, 数据以键值对的形式存储, 可以存储多种类型的值, 如字符串、列表、哈希表等
• 内存数据库: Redis 将数据存储在内存中, 因此读取和写入速度非常快, 适合高速缓存和需要快速访问的应用场景
• 高性能: Redis 具有高并发性能和低延迟, 适合处理实时数据和高频读写操作
• 适用场景: 适合缓存、会话管理、排行榜、发布/订阅等场景, 以及需要高性能、低延迟的应用程序

总结: 关系型数据库适合存储结构化数据和复杂的关系查询, MongoDB 适合存储非结构化数据和需要灵活性、可扩展性的场景, 而 Redis 适合高速缓存和需要快速访问的应用场景。选择合适的数据库取决于数据的特性、应用程序的需求以及性能和可扩展性的要求。在某些情况下, 这些数据库系统也可以结合使用, 以满足不同的需求

服务熔断

服务器的熔断机制是一种用于保护系统和服务稳定性的机制。它是一种自动化的故障处理机制, 旨在避免系统由于故障或异常情况而崩溃或无法正常工作

熔断机制通常在分布式系统和微服务架构中使用, 用于处理服务间的通信和依赖关系。当一个服务发生故障或异常时, 熔断机制会自动断开对该服务的调用, 并在一段时间内阻止对该服务的进一步请求。这样可以避免故障服务的连锁反应, 保护系统的稳定性和可靠性

熔断机制的主要目标是:

1. 快速失败: 在服务发生故障或异常时, 立即中断对该服务的调用, 而不是等待超时或无限等待响应
2. 避免资源浪费: 停止对故障服务的请求可以释放资源, 避免浪费服务器资源和网络带宽
3. 快速恢复: 熔断机制通常会有一个恢复时间窗口, 在该时间窗口内尝试重新调用故障服务, 以验证其是否已经恢复正常。如果故障服务恢复正常, 则继续正常的请求转发

熔断机制的实现通常通过设置一些 阈值和监控机制 来触发熔断和恢复。例如, 可以设置对服务的请求失败率、响应时间超过阈值等指标进行监控, 当这些指标超过预设的阈值时, 触发熔断操作

熔断机制的好处是可以提高系统的稳定性和可用性, 避免故障服务对整个系统的影响。它还可以减少客户端对故障服务的等待时间, 提供更好的用户体验。同时, 熔断机制也可以提供实时的故障监控和告警信息, 帮助运维人员及时发现和解决问题

总而言之, 服务器的熔断机制是一种自动化的故障处理机制, 用于保护系统和服务的稳定性。通过快速失败、避免资源浪费和快速恢复等措施, 它可以防止故障服务对整个系统造成连锁反应, 并提供更好的用户体验和系统可靠性

uv/vv/pv/dau/gmv/tr

在互联网和网站分析领域中, UV、PV 和 VV 是常用的指标, 用于衡量网站流量和用户活跃度

• UV(Unique Visitor)表示独立访客数, 即在一段时间内(通常是一天), 访问网站的不同用户数量。UV 指标用于计算网站的用户数量和覆盖范围, 每个独立访客只计算一次, 无论其在该时间段内访问了多少次
• PV(Page View)表示页面浏览量, 即网站在一段时间内的页面浏览次数。每当用户访问一个页面, PV 就会增加一次。PV 指标用于衡量网站的流量和页面受欢迎程度, 高 PV 值通常表示用户对网站内容的浏览兴趣
• VV(Visit View)表示访问次数, 即在一段时间内的访问次数。VV 指标统计了用户对网站的不同访问行为, 每次用户进入网站算作一次访问, 无论期间有多少页面浏览
• DAU(Daily Active User)日活跃用户数量
• MAU(monthly active users)月活跃用户人数
• GMV(Gross Merchandise Volume,网站成交金额) 通常称为网站成交金额, 属于电商平台企业成交类指标, 主要指拍下订单的总金额, 包含付款和未付款两部分
• TR(Through Rate 或 True Reach):
  • Through Rate: 指点击率(CTR - Click Through Rate),即广告被展示后用户点击的比例。这个指标常用于评估广告的吸引力和效果
  • True Reach: 也可能指实际覆盖人数,表示广告或内容真正到达了多少独立的用户,这通常用来评估广告的实际传播范围

这些指标在网站分析中被广泛使用, 可以帮助分析师和网站管理员了解网站的流量情况、用户活跃度和用户行为, 从而进行数据分析和优化网站策略

FaaS

FaaS(Function as a Service)。 更多介绍 点击 (opens new window)

FaaS 模型使研发人员能够将更多的精力集中在编写业务逻辑上, 而不必担心底层基础设施的维护。这种模型的弹性和自动化能力也使其适用于各种不同类型的应用, 尤其是需要应对波动负载的应用

FaaS 具有如下特性

• 编码简单、轻量 - 可基于平台为各语言(Node.js、Python、Shell、Java )定义的规范编写代码, 快速开发业务逻辑
• 扩展性好 - 支持自定义运行时(Custom Runtime), 并通过层, 可方便植入业务依赖, 无须自定义镜像
• 内置基础组件 - 内置 Dubbo、HTTP、MySQL、Redis、Leo 等基础组件访问, 按需使用
• 较高的资源利用率 - 接入弹性系统, 可按需扩容计算资源, 一些场景下支持服务资源缩容到 0 实例
• 安全可靠 - 支持在不同可用区部署, 支持跨区跨云容灾, 提供极高的容错性
• 支持 HTTP 触发 - 支持各类 LB 触发, 流量配置策略灵活
• MQ 消息触发 - 支持 Tiger 消息触发, 无须关注消息系统的连接配置细节, 天然跨语言
• 开发工具支持 - 支持在线代码编辑和 IDE 插件(VSCode \ Intellij), 并通过 faas-cli 支持常用组件(如)的配置自动生产
• 和常用基础服务联通 - 如水滴, ABTest, 华山, 衡山等

调用和启动流程

FaaS(Function as a Service)调用和启动流程通常包括以下步骤:

1. 事件触发: FaaS 函数的启动通常是由外部事件触发的。这些事件可以来自各种来源, 例如 HTTP 请求、消息队列、存储桶的变化、定时触发器等

2. 事件传递: 当事件触发时, 相应的事件数据将传递给 FaaS 平台

3. 函数初始化: 如果尚未有活动的函数实例(或者函数实例被回收了), FaaS 平台将启动新的函数实例。这个过程被称为 "冷启动"。在冷启动过程中, 平台会初始化函数的运行时环境, 加载函数代码, 配置运行环境等。这一过程的时间在通常情况下很短, 但在某些情况下可能会有延迟

4. 执行函数: 一旦函数实例启动并初始化完成, 平台将事件数据传递给函数的处理程序(handler)。函数的处理程序开始执行业务逻辑, 根据事件数据进行处理

5. 返回结果: 函数执行完成后, 可以生成响应并将其返回给触发事件的来源。响应可以是 HTTP 响应、消息队列消息、存储桶的变化等, 具体取决于事件的类型

6. 回收函数实例: 在某些 FaaS 平台上, 函数实例可以在一段时间后回收, 以节省资源。这个过程被称为 "回收"。如果函数实例被回收, 下次触发事件时需要再次进行初始化

7. 日志和监控: FaaS 平台通常提供了日志和监控功能, 以便开发人员可以跟踪函数的执行情况, 诊断问题并监视性能

整个过程是自动的, 开发人员只需关注编写函数的业务逻辑, 而不必担心底层的服务器、容器或虚拟机的管理。这种模型具有高度的弹性, 适用于需要快速响应事件的应用程序, 同时可以根据负载自动扩展和回收资源

染色概念

uid 染色

通过 UID(User ID)染色是一种常见的技术手段, 用于在公司的平台或系统中对用户进行标识、分组或定制化处理。UID 是唯一标识用户的标识符, 每个用户在系统中都有一个唯一的 UID

UID 染色的过程通常包括以下几个步骤:

• 用户注册或登录: 当用户在公司的平台上注册或登录时, 系统会为其分配一个唯一的 UID

• UID 绑定: 在用户注册或登录后, 系统将 UID 与用户的个人信息进行绑定, 以便后续识别和操作

• UID 映射: 公司的平台会根据业务需求, 将特定的功能、服务或内容与特定的 UID 进行映射。这样可以针对不同的用户群体进行个性化处理

• 染色规则定义: 在 UID 染色过程中, 公司会定义一系列染色规则或条件。这些规则可能基于用户的属性、行为、偏好等信息, 用于将用户划分为不同的群体或标签

• 个性化处理: 通过 UID 染色, 公司可以根据染色规则将用户分配到相应的群体或标签中, 并针对不同群体提供个性化的功能、服务或内容。例如, 向特定群体的用户展示特定的推荐内容、定制化的界面布局等

UID 染色可以帮助公司更好地理解和满足用户的需求, 提供更个性化、精准的用户体验。它可以用于用户分析、精准营销、A/B 测试等场景, 帮助公司优化产品和服务, 提升用户满意度和业务效果

websocket 的实现方式

从 demo-websocket (opens new window) 示例中看出.

• 前端可以基于 sockJs(浏览器中处理 WebSocket 连接) 使用 STOMP (opens new window) 协议进行
• 后端使用 org.springframework.boot:spring-boot-starter-websocket 来实现

Dao(Data Access Object)

是一种模式, 用于在应用程序和数据存储之间提供一个抽象层, 以简化数据存储访问。它通常是用于创建、更新、检索和删除数据的方法的集合, 并且它涵盖了数据存储的所有细节, 以便应用程序可以专注于业务逻辑。因此, 它是数据操作层的重要组成部分

mapper

在 Java 中, "Mapper" 是一个常见的术语, 通常用于描述一种用于将数据从一种形式映射到另一种形式的工具或组件。在不同的上下文中, "Mapper" 可以表示不同的含义, 以下是其中一些常见的用法:

1. 数据访问对象(Data Access Object)Mapper:

在数据访问层中, Mapper 通常是指数据访问对象(DAO)的一部分。它用于将数据库表的记录(通常是关系型数据库表)映射到 Java 对象, 或者将 Java 对象映射到数据库表。这是一种常见的 ORM(对象关系映射)模式的实现。例如, 在使用 Hibernate、MyBatis 或 JPA 等持久化框架时, 通常会编写 Mapper 接口或配置文件来定义对象到数据库表的映射关系

// MyBatis Mapper Interface
public interface UserMapper {
    User getUserById(int id);
    void insertUser(User user);
}

2. 对象映射器(Object Mapper):

在处理不同数据格式(例如 JSON、XML)的时候, 对象映射器通常用于将数据转换为 Java 对象或将 Java 对象转换为数据。一些流行的 Java 对象映射器包括 Jackson(用于 JSON)、JAXB(Java Architecture for XML Binding, 用于 XML)、Dozer 等

// 使用 Jackson ObjectMapper 将 JSON 字符串转换为 Java 对象
ObjectMapper objectMapper = new ObjectMapper();
User user = objectMapper.readValue(jsonString, User.class);

3. 模型-视图映射器(Model-View Mapper):

在 Web 应用程序中, 模型-视图映射器通常用于将应用程序的模型数据映射到视图层(通常是 HTML 或其他视图模板)以进行渲染。一些 Java Web 框架(例如 Spring MVC)提供了视图解析器和模型映射器, 用于处理这种类型的映射

// Spring MVC Controller method with Model-View Mapping
@GetMapping("/user/{id}")
public String getUser(@PathVariable("id") int id, Model model) {
    User user = userService.getUserById(id);
    model.addAttribute("user", user);
    return "user-profile"; // View name
}

4. 其他映射器:

在不同领域中, Mapper 可能具有不同的含义。例如, 图形映射器用于将图像的像素映射到屏幕上, 地图映射器用于将地理坐标映射到地图上, 等等

总之, "Mapper" 是一个通用的术语, 它描述了一种将数据从一种形式映射到另一种形式的工具或组件。在不同的上下文中, 它可以表示不同类型的映射, 包括数据访问、对象映射、模型-视图映射以及其他领域中的映射。在 Java 中, 您可以使用各种库和框架来实现这些映射

JDBC(Java Database Connectivity)

• 定义: JDBC 是 Java 用于与关系型数据库交互的标准 API。它允许 Java 应用程序与数据库建立连接、执行 SQL 查询、插入、更新和删除数据
• 用途: JDBC 用于直接管理数据库连接和执行 SQL 操作。它是一个底层的、面向关系型数据库的 API。开发人员需要手动编写 SQL 语句, 并处理数据库连接、事务等细节
• 工作方式: JDBC 提供了一组接口和类, 允许 Java 应用程序执行以下操作:
  • 建立数据库连接
  • 创建和执行 SQL 语句
  • 处理结果集
  • 管理事务
• 示例: 以下是一个简单的 JDBC 示例, 用于连接到数据库并执行查询操作:

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

public class JDBCDemo {
    public static void main(String[] args) {
        try {
            Class.forName("com.mysql.jdbc.Driver");
            Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb", "username", "password");
            Statement statement = connection.createStatement();
            ResultSet resultSet = statement.executeQuery("SELECT * FROM users");
            while (resultSet.next()) {
                System.out.println(resultSet.getString("username"));
            }
            resultSet.close();
            statement.close();
            connection.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

JPA(Java Persistence API)

• 定义: JPA 是 Java 的持久化 API, 用于将 Java 对象映射到数据库表。它提供了一种更高级别、面向对象的方式来处理持久化, 而不需要编写大量的 SQL 代码
• 用途: JPA 用于简化数据持久化的过程, 提供了对象关系映射(ORM)的功能。它允许开发人员通过定义实体类和注解来描述数据库表和对象之间的映射, 而不需要编写复杂的 SQL 查询
• 工作方式: JPA 通过注解或 XML 配置文件来描述实体类与数据库表之间的映射关系。开发人员可以使用 JPA 提供的 API 来执行 CRUD(创建、读取、更新、删除)操作, 而不需要编写原始 SQL 语句
• 示例: 以下是一个简单的 JPA 示例, 用于定义实体类和执行查询操作:

import javax.persistence.*;

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "username")
    private String username;

    // Getters and setters
}

// 使用 JPA 查询
EntityManagerFactory emf = Persistence.createEntityManagerFactory("my-persistence-unit");
EntityManager em = emf.createEntityManager();
TypedQuery<User> query = em.createQuery("SELECT u FROM User u WHERE u.username = :username", User.class);
query.setParameter("username", "john");
List<User> users = query.getResultList();

JWT

JWT (opens new window)(JSON Web Token)是一种用于在网络应用之间安全传输信息的开放标准(RFC 7519)。它通过使用数字签名或加密来验证信息的可信性, 通常用于实现用户身份验证和授权

JWT (JSON Web Token) 的组成

JWT 是一种开放标准(RFC 7519)定义的令牌格式,常用于认证和信息交换。它由三个部分组成,使用点号 (.) 分隔：

1. Header(头部)

• 描述令牌的元信息,例如签名算法
• 通常是一个 JSON 对象,Base64Url 编码后形成 JWT 的第一部分

示例：

{
    "alg": "HS256", // 签名算法 (e.g., HMAC-SHA256)
    "typ": "JWT" // 令牌类型
}

2. Payload(载荷)

• 包含声明(claims),即 JWT 携带的信息。可以分为：
  • 注册声明：标准字段,如 sub(主题)、iat(签发时间)、exp(过期时间)等
  • 公共声明：应用自定义的非敏感信息字段
  • 私有声明：仅在双方之间约定使用的字段
• JSON 对象,Base64Url 编码后形成第二部分

示例：

{
    "sub": "1234567890", // 用户 ID
    "name": "John Doe", // 用户名
    "iat": 1516239022 // 签发时间
}

3. Signature(签名)

• 用于验证 JWT 是否被篡改
• 生成方式：

HMACSHA256(
  base64UrlEncode(header) + "." + base64UrlEncode(payload),
  secret
)

• 包含密钥和算法签名的字符串,是 JWT 的第三部分

---

1. JWT 认证的工作原理如下:

• 用户登录: 用户通过提供有效的凭证(通常是用户名和密码)来登录应用程序
• 生成 JWT: 一旦用户成功登录, 服务器将生成一个 JWT。JWT 通常包含以下信息:
  • 用户标识(例如用户 ID 或用户名)
  • 过期时间(JWT 的有效期)
  • 其他自定义的声明(例如用户角色、权限等) 服务器使用一个密钥来签名 JWT, 以确保它的完整性和真实性
• 将 JWT 发送给客户端: 生成的 JWT 将被发送回客户端, 通常存储在客户端的 Cookie 或本地存储中
• 客户端请求受保护资源: 当客户端尝试访问需要身份验证的资源时, 它将在请求中包含 JWT。通常, JWT 放在请求的授权头(Authorization Header)中, 以 Bearer Token 的形式传递
• 服务器验证 JWT: 服务器收到包含 JWT 的请求后, 将验证 JWT 的签名以确保其完整性和真实性。如果 JWT 有效且未过期, 则服务器将允许访问受保护的资源
• 响应受保护资源: 如果 JWT 有效, 服务器将响应客户端请求并提供受保护资源

2. JWT 认证的优点包括

• 无状态
  • 服务端无需存储会话信息,JWT 携带了所有认证所需的信息
  • 适合分布式系统和微服务架构
• 签名校验：
  • 防止篡改。只有拥有密钥的一方可以生成合法签名,非法修改会导致签名校验失败
• 携带自定义信息：
  • 可以在载荷中携带用户权限、角色等信息,减少数据库查询的频率
• 跨平台：
  • 使用标准化格式(JSON 和 Base64Url),可在任何语言环境中使用

3. 安全性问题：

• 敏感数据泄露风险：
  • JWT 的载荷部分没有加密,任何持有令牌的人都可以解码其中的信息(通过 Base64Url 解码)。不要在载荷中存储敏感信息,如密码
• 令牌泄露风险：
  • 一旦令牌被窃取,攻击者可以冒充用户,直到令牌过期
  • 防范措施：
    • 短生命周期：设置 exp 字段,使令牌迅速过期
    • 使用 HTTPS：确保传输中的令牌不被窃听
    • 配合 refresh token：用更长效的刷新令牌来获取短生命周期的访问令牌
• 密钥管理：
  • 使用对称算法(如 HMAC)时,密钥需要妥善管理
  • 建议使用非对称算法(如 RSA),可分开管理公钥和私钥
• 令牌吊销困难：
  • JWT 一经签发,服务端无法强制使其失效,除非额外实现令牌黑名单
  • 防范措施：
    • 使用短生命周期的令牌
    • 实现刷新机制或令牌撤销机制

Swagger3

Swagger 3.0 是一种用于定义、构建和文档化 RESTful API 的规范。它使开发人员能够创建具有可读性和易于理解的 API 文档, 同时还提供了工具和库来自动生成客户端 SDK 和服务器存根。以下是如何使用 Swagger 3.0 来定义和文档化 Java 中的 RESTful API 的基本步骤:

1. 添加 Swagger 依赖:

首先, 您需要在 Java 项目中添加 Swagger 的依赖库。这通常包括 swagger-core 和 swagger-ui。您可以使用 Maven 或 Gradle 来添加这些依赖 使用 Maven, 您可以将以下依赖添加到您的 pom.xml 文件中:

<dependency>
    <groupId>io.swagger.core.v3</groupId>
    <artifactId>swagger-core</artifactId>
    <version>2.1.10</version>
</dependency>
<dependency>
    <groupId>org.webjars</groupId>
    <artifactId>swagger-ui</artifactId>
    <version>3.51.3</version>
</dependency>

2. 创建 API 文档:

在 Java 代码中, 您可以使用 Swagger 注解来描述您的 RESTful API。Swagger 提供了一些常用的注解, 如 @Api, @ApiOperation, @ApiParam 等, 用于定义 API 的信息、操作和参数

import io.swagger.annotations.*;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api")
@Api(tags = "Sample API")
public class SampleController {
    @GetMapping("/hello")
    @ApiOperation("Say hello")
    public String sayHello(
        @RequestParam(value = "name", defaultValue = "World")
        @ApiParam("Name to greet") String name
    ) {
        return "Hello, " + name + "!";
    }
}

3. 配置 Swagger:

在您的 Java 应用程序中, 您需要配置 Swagger 来生成 API 文档。这通常涉及创建一个 Swagger 配置类, 并将其与 Spring Boot 或其他 Java 框架集成

import org.springframework.context.annotation.*;
import springfox.documentation.spring.web.plugins.*;
import springfox.documentation.swagger2.annotations.*;

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

4. 访问 Swagger UI:

启动您的 Java 应用程序后, 您可以在浏览器中访问 Swagger UI, 通常位于 /swagger-ui.html。这将显示一个可交互的 API 文档, 允许您浏览和测试您的 API 例如: http://localhost:8080/swagger-ui.html (opens new window)

这些是使用 Swagger 3.0(OpenAPI 3.0)来定义和文档化 Java RESTful API 的基本步骤。通过注解和配置, 您可以更详细地定义您的 API, 包括操作、请求和响应。Swagger 将根据这些信息生成详细的 API 文档, 并提供交互式界面来测试 API。这有助于团队更好地理解和使用您的 API

RESTful API

RESTful API(Representational State Transfer API)是一种基于 HTTP 协议的应用程序编程接口(API)设计风格, 它采用了一组约定和约束, 旨在使网络应用程序更加简单、可伸缩和易于扩展。RESTful API 的设计风格是由 Roy Fielding 在他的博士论文中首次提出的, 并成为了构建分布式网络应用的一种常见方式

以下是 RESTful API 的主要特点和原则:

1. 资源(Resources): 在 RESTful API 中, 一切都是资源, 每个资源都有一个唯一的标识符(通常是 URL)。资源可以是物理实体(例如数据库记录)、虚拟实体(例如计算机服务)或抽象概念(例如订单或用户)

2. HTTP 动词: RESTful API 使用 HTTP 方法来执行操作。常见的 HTTP 动词包括 GET(获取资源)、POST(创建资源)、PUT(更新资源)和 DELETE(删除资源)。这些动词与资源的 CRUD 操作(创建、读取、更新、删除)相对应

3. 状态无关性(Statelessness): 每个 HTTP 请求都包含了足够的信息, 服务器不需要保存客户端的状态。每个请求都应该是独立的, 这样可以更容易实现负载均衡和横向扩展

4. 统一接口(Uniform Interface): RESTful API 的接口应该是简单、一致和易于理解的。这使得客户端能够轻松地与不同的服务进行交互

5. 资源的表述(Resource Representation): 资源的表述是资源的具体数据, 通常以 JSON 或 XML 格式返回给客户端。客户端可以使用这些表述来操作资源

6. 无状态通信(Stateless Communication): 每个请求都应该包含足够的信息, 以便服务器可以理解它, 而不需要查看之前的请求。这使得 RESTful API 易于缓存和代理

7. 自我描述性(Self-Descriptive Messages): 每个请求和响应都应该包含足够的信息, 以便客户端和服务器都能理解它, 而不需要事先了解上下文

8. 按需响应(On-Demand Response): 客户端决定何时请求资源, 服务器不会自动推送数据。这使得客户端可以按需获取数据, 减少不必要的网络流量

RESTful API 通常使用 URL 来唯一标识资源, 使用 HTTP 方法来执行操作, 使用状态码来表示操作的结果。它们可以通过 URL 参数、HTTP 头部和请求体来传递数据, 通常使用 JSON 或 XML 格式返回数据

总之, RESTful API 是一种简单、可伸缩和易于理解的 API 设计风格, 广泛用于构建 Web 服务和分布式系统。它的设计原则强调资源、状态无关性和统一接口, 使得开发者能够构建灵活和可维护的应用程序

AspectJ 实现 AOP

在 Spring 中, 您可以使用 AspectJ 来实现面向切面编程(AOP)。AspectJ 是一个强大的 AOP 框架, 它可以与 Spring 集成以实现更复杂的横切关注点。以下是在 Spring 中使用 AspectJ 来实现 AOP 的一般步骤:

1. 添加 AspectJ 依赖: 首先, 您需要在项目中添加 AspectJ 的依赖。如果使用 Maven, 可以在 pom.xml 中添加以下依赖:

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.7</version> <!-- 使用合适的版本 -->
</dependency>

2. 创建切面类: 创建一个 Java 类来充当您的切面。切面类通常包含各种通知(Advice), 以定义在何时和何地执行横切关注点。一个简单的切面类示例:

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class MyAspect {
    @Before("execution(* com.example.service.*.*(..))")
    public void beforeServiceMethods() {
        // 在service包中的所有方法执行前执行此通知
        System.out.println("Before executing a service method...");
    }
}

在上面的示例中, @Aspect 注解将该类标记为一个切面, @Before 注解定义了一个前置通知, 它在 com.example.service 包中的所有方法执行前执行

3. 配置 AspectJ 支持: 在 Spring 配置文件中启用 AspectJ 支持。您可以使用 XML 配置或基于 Java 的配置来完成这一步

• XML 配置示例:

<aop:aspectj-autoproxy/>

• Java 配置示例:

import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@EnableAspectJAutoProxy
public class AppConfig {
    // 其他配置...
}

4. 在目标 Bean 上应用切面: 确保您的切面生效, 需要在目标 Bean 上应用切面。您可以使用 @Component 或其他 Spring 组件扫描注解来确保目标 Bean 被 Spring 管理

5. 运行应用程序: 启动您的 Spring 应用程序。AspectJ 将会自动拦截匹配切点表达式的方法, 并在适当的时候执行通知

6. 验证 AOP 效果: 调用目标 Bean 上的方法, 然后检查切面的通知是否按预期执行

这些是使用 AspectJ 在 Spring 中实现 AOP 的一般步骤。您可以根据具体的需求和场景定义不同类型的通知(前置、后置、环绕等)以及切点表达式来捕获不同的横切关注点。AspectJ 提供了丰富的语法和功能, 以满足各种 AOP 需求

---

AspectJ 的工作原理涉及以下几个关键概念和组件

• 切面(Aspect): 切面是一个模块, 它包含了一组通知(Advice)和切点(Pointcut)。通知定义了在何时和何地执行横切关注点, 而切点定义了在何处执行通知

• 通知(Advice): 通知是切面的具体行为。AspectJ 支持多种类型的通知, 包括前置通知(Before)、后置通知(After)、环绕通知(Around)等。通知是在切点处执行的代码片段

• 切点(Pointcut): 切点是一个表达式, 它定义了在程序中的哪些位置执行通知。切点可以使用 AspectJ 的切点表达式语言来定义, 例如, 执行某个包中的所有方法或者执行某个特定注解标记的方法

• 连接点(Join Point): 连接点是程序执行过程中的一个具体点, 例如方法的调用、方法的执行、对象的创建等。连接点是切点的实际实例, 它是通知实际执行的地方

• 织入(Weaving): 织入是将切面与应用程序的目标代码连接在一起的过程。在编译时、类加载时或运行时, AspectJ 可以将切面织入到目标代码中, 以执行通知

• 目标对象(Target Object): 目标对象是应用程序中的原始对象, 它可能包含横切关注点。切面可以通过通知来影响目标对象的行为

AspectJ 的工作原理可以概括为以下几个步骤

1. 定义切面: 开发人员定义一个切面, 其中包含了通知和切点的定义

2. 编写切点表达式: 开发人员编写切点表达式, 以指定在何处执行通知。切点表达式可以选择性地使用各种条件, 如方法名称、方法参数、注解等

3. 织入切面: AspectJ 在适当的时机将切面织入到目标代码中。这可以在编译时、类加载时或运行时进行

4. 执行通知: 当程序执行达到切点时, AspectJ 执行与切点相关联的通知。通知可以在切点之前、之后或代替切点执行

CDN, p2p 和 PCDN

• CDN: 即 Content Delivery Network, 中文全称为内容分发网络
• P2P: 即 Peer-To-Peer, 应用于互联网上, 是指一种点对点传输的网络结构, 形象地描述为图１这样一个搭档式的组织结构。如同人与人之间的交流, 每个节点(也就是搭档)之间地位相同, 又相互独立, 处于对等状态, 不以个人为中心
• PCDN: 在 CDN 产品的基础上融合新一代 P2P 技术, 充分利用边缘网络海量碎片化的计算、存储、网络等闲置资源构建低成本、高质量的内容分发网络服务。通过创新的分发网络优化技术和精准的智能调度系统, 在为用户提供稳定、高质量的分发加速服务的同时, 显著降低分发成本

常用依赖

lombok

org.projectlombok:lombok:Lombok 是一个 Java 库, 它通过使用注解来减少 Java 代码的样板代码, 从而简化 Java 开发

@Data注解是 Lombok 库中的一个注解, 它可以自动生成 Java 类的通用方法, 如 toString、equals、hashCode 和Getter/Setter方法等。然而, 如果您想要使用@Data注解生成 Getter 方法, 但不生成 Setter 方法, 可以使用@Getter 注解来实现这一目标。以下是示例:

import lombok.Data;
import lombok.Getter;

@Data
public class MyData {
    private String field1;

    // 使用@Getter注解生成Getter方法, 但不生成Setter方法
    @Getter
    private String field2;
}

在这个示例中, @Data注解用于自动生成通用方法, 包括 Getter 方法。然而, 通过在 field2 上使用@Getter 注解, 我们告诉 Lombok 只生成 Getter 方法, 而不生成 Setter 方法

这样, 对于 field1, @Data会生成 Getter 和 Setter 方法, 而对于 field2, 只会生成 Getter 方法

请确保您已经将 Lombok 库添加到项目的依赖中, 以便使用这些注解。通常, 您需要在项目的 build.gradle 或 pom.xml 文件中添加 Lombok 的依赖

声明

implementation 'org.projectlombok:lombok:1.18.22'
annotationProcessor 'org.projectlombok:lombok:1.18.22'

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>

// Make sure to add code blocks to your code group

在 maven 申明中, 如果@Data注解不生成相关方法, 可以尝试。 reload maven 根据 IDE 的提示操作

logback

Logback 是一个开源的日志框架, 用于在 Java 应用程序中记录日志。它是 log4j 框架的继承者, 并提供了更多的功能和性能优化。Logback 被广泛用于各种 Java 应用程序中, 包括 Web 应用、企业应用和后端服务。以下是 Logback 的主要特点和用法:

特点:

• 高性能: Logback 被设计为高性能的日志框架, 能够在不影响应用程序性能的情况下记录大量日志

• 灵活的配置: Logback 支持 XML 和 Groovy 等多种配置方式, 允许开发人员灵活配置日志记录器、格式化器、输出目标等

• 多种输出目标: Logback 支持多种输出目标, 包括控制台、文件、远程服务器、数据库等。您可以根据需要将日志记录到不同的地方

• 异步日志记录: Logback 支持异步日志记录, 可以将日志记录操作异步执行, 以提高应用程序的性能

• 可插拔的组件: Logback 的组件(如 Appenders、Layouts 和 Filters)都是可插拔的, 可以根据需求进行扩展或替换

• 日志级别: Logback 支持不同的日志级别, 包括 TRACE、DEBUG、INFO、WARN 和 ERROR, 允许开发人员根据需要记录不同详细程度的日志

用法:

1. 添加 Logback 依赖: 首先, 在项目的依赖管理中添加 Logback 的依赖。通常, 您可以在 Maven 或 Gradle 中添加以下依赖:

<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>2.0.0</version>
</dependency>

2. 创建 Logback 配置文件: 您需要创建 Logback 的配置文件, 通常命名为logback.xml或logback.groovy。该文件用于配置日志记录器、输出目标、格式化等

以下是一个示例的 logback.xml 配置文件:

<configuration>
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
    <root level="debug">
        <appender-ref ref="CONSOLE" />
    </root>
</configuration>

3. 在代码中使用 Logback: 在应用程序代码中, 您可以通过 Logback 的日志记录器(Logger)来记录日志。通常, 您需要在类中创建一个 Logger 实例, 并使用不同级别的日志记录方法来记录信息

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class MyClass {
    private static final Logger logger = LoggerFactory.getLogger(MyClass.class);

    public void doSomething() {
        logger.debug("Debug message");
        logger.info("Info message");
        logger.warn("Warning message");
        logger.error("Error message");
    }
}

4. 运行和查看日志: 运行应用程序后, Logback 将根据配置记录日志。您可以在控制台、日志文件或其他配置的输出目标中查看日志信息

总之, Logback 是一个功能强大且易于使用的日志框架, 它可以帮助您在 Java 应用程序中进行灵活和高性能的日志记录。通过合适的配置和日志级别, 您可以控制日志的详细程度, 并轻松地跟踪和调试应用程序

mybatis

链接:

• Mybatis 官方文档: http://www.mybatis.org/mybatis-3/zh/index.html (opens new window)
• Mybatis 官方脚手架文档: http://www.mybatis.org/spring-boot-starter/mybatis-spring-boot-autoconfigure/ (opens new window)
• Mybatis 整合 Spring Boot 官方 demo: https://github.com/mybatis/spring-boot-starter/tree/master/mybatis-spring-boot-samples (opens new window)

原理简述:

MyBatis 是一个流行的 Java 持久性框架, 它提供了一种将 Java 对象映射到数据库表的方法, 同时还支持灵活的 SQL 查询。下面是 MyBatis 的一些核心原理和工作方式:

• SQL 映射文件

  MyBatis 的核心是 SQL 映射文件, 这些文件包含了 SQL 语句和映射规则, 将 Java 对象与数据库表进行映射。每个映射文件通常对应一个数据库表, 并定义了如何将数据从数据库表映射到 Java 对象以及反之

• 配置文件

  MyBatis 需要一个配置文件来初始化和配置框架。该配置文件指定了数据库连接信息、映射文件的位置、缓存策略等配置选项。这个配置文件通常是 mybatis-config.xml

• SqlSessionFactory

  SqlSessionFactory 是 MyBatis 的核心接口之一, 它是用于创建 SqlSession 的工厂。SqlSession 是 MyBatis 中用于执行 SQL 操作的主要接口

• SqlSession

  SqlSession 表示与数据库的一次会话, 它提供了执行 SQL 语句、提交事务、关闭会话等操作。通常, 每个数据库操作都需要创建一个 SqlSession 实例

• Mapper 接口

  MyBatis 支持将 SQL 映射文件中的 SQL 语句绑定到 Java 接口的方法上。开发者可以创建 Mapper 接口, 并使用注解或 XML 配置将接口方法与 SQL 语句进行绑定。MyBatis 会自动生成 Mapper 接口的实现类, 用于执行 SQL 操作

• 执行 SQL 查询

  当应用程序调用 Mapper 接口的方法时, MyBatis 会根据方法的配置找到相应的 SQL 语句, 并将参数传递给 SQL 语句执行。查询结果将被映射到 Java 对象, 并返回给调用方

• 缓存

  MyBatis 支持查询结果的缓存, 以提高性能。它支持两种缓存: 本地缓存(SqlSession 级别)和二级缓存(全局级别)。开发者可以根据需求配置缓存

• 动态 SQL

  MyBatis 允许使用动态 SQL 构建复杂的 SQL 查询。动态 SQL 允许根据条件包含或排除 SQL 语句的一部分, 以实现动态的 SQL 查询

• 事务管理

  MyBatis 支持事务管理, 可以通过配置来启用或禁用事务。开发者可以使用 commit 和 rollback 操作来管理事务

• 插件机制

  MyBatis 提供了一个插件机制, 允许开发者扩展框架的功能。您可以编写自定义插件, 例如自定义拦截器, 来干预 SQL 执行过程

总之, MyBatis 的核心原理涉及 SQL 映射文件、配置文件、SqlSessionFactory、SqlSession、Mapper 接口、SQL 执行、缓存、事务管理等组件的协同工作, 使开发者能够轻松地进行数据库访问并进行对象-关系映射。这使得 MyBatis 成为了一个强大且灵活的持久层框架

kibana

Kibana 是一个开源的数据可视化工具, 通常与 Elasticsearch 结合使用, 用于实时地探索、分析和可视化存储在 Elasticsearch 中的数据。Kibana 的主要功能包括:

• 数据可视化: Kibana 允许用户创建各种类型的数据可视化, 包括折线图、柱状图、饼图、地图、仪表盘等, 以便更直观地理解数据

• 实时搜索和过滤: 用户可以使用 Kibana 的搜索和过滤功能, 轻松地在大量数据中查找、筛选和定位感兴趣的信息

• 仪表盘: Kibana 仪表盘是一个可自定义的集合, 可以将多个可视化组件组合到一个页面上, 以创建自己的仪表盘, 以便监控关键性能指标和数据

• 日志和事件数据分析: Kibana 被广泛用于分析大规模的日志和事件数据, 帮助运维人员、开发人员和安全团队查找问题、追踪日志、发现异常和实施安全监控

• 地理数据可视化: Kibana 具有地图可视化功能, 可以在地图上显示地理位置相关的数据, 如地理热图、点云图、区域边界等

• 插件扩展: Kibana 是可扩展的, 可以通过插件和扩展来增强其功能, 满足不同的需求。Elastic 提供了丰富的插件, 同时社区也开发了许多第三方插件

• 用户管理和访问控制: Kibana 支持用户认证和授权, 可以配置不同用户和角色的访问权限, 以保护敏感数据和控制用户能够执行的操作

• 集成 Elasticsearch: Kibana 最常与 Elasticsearch 集成使用, Elasticsearch 作为数据存储和检索引擎, Kibana 则负责数据可视化和分析。这个组合通常与 Logstash 一起使用, 形成 ELK 堆栈, 用于处理、存储和可视化日志数据

总之, Kibana 是一个功能强大的数据可视化工具, 适用于各种领域, 包括运维监控、应用性能分析、日志分析、安全信息与事件管理(SIEM)等。它可以帮助用户更好地理解和利用其数据, 以做出更明智的决策和行动

Kubernetes

Kubernetes(通常缩写为 K8s)是一个开源的容器编排平台, 用于自动化应用程序的部署、扩展和管理。Kubernetes 服务器开发涉及构建和维护 Kubernetes 的核心组件, 以及为 Kubernetes 编写扩展和插件。在 Kubernetes 中, 最小的可部署和调度单位是 "Pod", 它可以包含一个或多个容器。以下是 Kubernetes 服务器开发的主要方面和任务:

1. 核心组件开发

• API 服务器(kube-apiserver): API 服务器是 Kubernetes 集群的控制平面组件之一, 它提供了 Kubernetes API 的端点。开发人员可以扩展 API 服务器以添加自定义 API 资源或自定义控制器
• 控制器管理器(kube-controller-manager): Kubernetes 中的控制器负责保持集群的期望状态。您可以编写自定义控制器来管理自定义资源
• 调度器(kube-scheduler): 调度器决定在哪个节点上运行 Pod。定制调度策略可能需要修改或扩展调度器

2. 插件和扩展

• CRI 插件: Container Runtime Interface(CRI)插件用于与容器运行时交互, 例如 Docker、containerd 等。开发自定义 CRI 插件以支持其他容器运行时
• CNI 插件: Container Network Interface(CNI)插件用于配置 Pod 之间和 Pod 与外部网络之间的网络连接。您可以开发自定义 CNI 插件以满足特定网络要求
• 扩展 API: Kubernetes 允许您自定义 API 资源和控制器, 以满足应用程序特定的需求。这可以通过 Kubernetes 的自定义资源定义(CRD)来实现

3. 安全性和认证

• 确保 Kubernetes 组件的安全性, 并实施适当的身份验证和授权机制以保护集群
• 开发和维护服务账户、角色和角色绑定, 以控制 Pod 对 Kubernetes API 的访问权限

4. 版本兼容性

• 跟踪 Kubernetes 的发行版本, 并确保自己的扩展和插件与不同版本的 Kubernetes 兼容

5. 测试和调试

• 编写单元测试、集成测试和端到端测试, 以确保自己的代码在 Kubernetes 集群中正常工作
• 开发和使用日志记录和监控工具, 以便追踪和解决问题

6. 社区参与

• Kubernetes 是一个开源项目, 具有活跃的社区。参与社区, 与其他开发人员合作解决问题, 讨论新功能和改进, 参加工作组和会议

7. 文档和教育

• 编写文档和教程, 以帮助其他开发人员了解如何使用和扩展 Kubernetes

Kubernetes 服务器开发是一个复杂的任务, 需要深入了解 Kubernetes 的核心原理和架构。此外, Kubernetes 社区提供了大量的文档和资源, 以帮助开发人员入门和深入研究 Kubernetes 开发

链接

• Kubernetes 架构详解 (opens new window)

openssl

OpenSSL 是一个强大的开源密码库, 它提供了一系列的密码学工具和函数, 用于保护通信的安全性。OpenSSL 被广泛用于网络通信、数据加密、数字证书管理以及许多其他领域, 包括安全套接层(SSL)和传输层安全(TLS)协议的实现

以下是 OpenSSL 的一些主要功能和用途:

• 加密和解密: OpenSSL 提供了各种密码算法, 包括对称密钥加密(如 AES、DES)、非对称密钥加密(如 RSA、DSA)以及哈希函数(如 SHA-256)。这些算法可以用于加密和解密数据, 确保数据在传输和存储过程中的机密性

• 数字证书: OpenSSL 可用于生成和管理数字证书。数字证书是用于验证通信方身份的重要工具, 常用于 HTTPS、电子邮件签名、虚拟专用网络(VPN)等应用中

• SSL/TLS 支持: OpenSSL 实现了安全套接层(SSL)和传输层安全(TLS)协议, 用于安全地传输数据。这是保护网页浏览和网络通信的关键技术

• SSL/TLS 证书颁发: OpenSSL 可用于创建自签名证书或生成证书签名请求(CSR), 这些证书通常用于建立安全的 HTTPS 连接

• 命令行工具: OpenSSL 提供了一系列命令行工具, 用于执行各种密码操作, 如生成密钥、创建数字证书、签名和验证数据等

• 密码学工具库: OpenSSL 提供了一组密码学函数, 可以集成到各种应用程序中, 用于加密和解密数据、生成随机数、计算哈希值等

• 跨平台支持: OpenSSL 被广泛支持, 可以在多个操作系统上使用, 包括 Linux、Windows、macOS 和其他 Unix 类系统

• 开源和免费: OpenSSL 是开源项目, 遵循 OpenSSL 许可证, 可以免费使用和分发

由于 OpenSSL 的强大功能和广泛应用, 它在网络安全、数据隐私和加密通信方面发挥着关键作用, 被许多应用程序和服务所采用。同时, 它也需要谨慎使用, 以确保正确的配置和维护, 以避免潜在的安全漏洞

函数扩容

"函数扩容"通常指的是在计算机科学和编程领域中的一个术语, 用来描述函数(或方法)的能力增强或功能的扩展。这可以通过以下几种方式实现:

• 添加新功能或功能参数: 在不改变现有代码的前提下, 可以通过向函数添加额外的参数或功能来扩展函数的能力。这样, 函数可以执行更多的任务或适应不同的用例

• 支持不同的数据类型: 通过改变函数的输入或输出, 可以使函数能够处理更多种类的数据。这通常包括支持更多的数据类型、数据结构或数据格式

• 改进性能或效率: 对函数进行扩容还可以包括对其进行性能优化, 使其更快或更节省资源。这可以通过算法优化、并行化、异步处理等方式来实现

• 添加异常处理: 为函数添加错误处理、边界情况的检查和异常处理功能, 以增加函数的健壮性和可靠性

• 提供更多选项: 通过添加配置参数、标志或开关, 可以让函数的行为变得更加灵活, 以适应不同的需求和情境

• 支持插件或扩展: 设计函数使其可以轻松地扩展或定制, 允许其他开发人员或模块添加自定义功能或扩展函数的功能

函数扩容的目的是增强函数的灵活性、可维护性和可重用性, 以便更好地满足不断变化的需求。在软件开发中, 扩容函数通常是为了避免修改现有代码, 而是通过扩展现有功能来实现新的需求, 从而减少潜在的错误和不稳定性

CDN

Content Delivery Network (CDN). link (opens new window)

kafka

消息队列

参考: https://juejin.cn/post/6974913928161656863 (opens new window)

优点

1. 系统解耦。生产端的服务和消息端的服务在遵守同样的接口约束条件下, 可以独立扩展和修改, 而互不影响
2. 流量削峰。面对突发大流量, 也即生产端生产速度比消费端的消费速度快的时候, 消费端服务不会因为超负荷的请求而完全崩溃
3. 可扩展性。因为生产者与消费者已经隔离解耦, 所以一旦想增加生产端或消费端的处理逻辑, 或者服务实例等都变得十分容易
4. 高吞吐量。以时间复杂度为 O(1) 的方式提供消息持久化能力, 即使对 TB 级以上数据也能保证常数时间复杂度的访问性能。即使在非常廉价的商用机器上也能做到单机支持每秒 100K 条以上消息的传输
5. 数据冗余存储。Kafka 支持多副本冗余存储机制, 保障不正常宕机之后数据不丢失
6. 消息顺序性。Kafka 分布式的单位是 partition, Kafka 保证同一个 partition 中的消息的有序性。一个 topic 多个 partition 时, 则不能保证 Topic 级别的消息有序性
7. 回溯消费。指的是 Kafka 重新设置消息位移 offset。kafka 支持两种方式回溯。一种是基于消息偏移量回溯, 一种是基于时间点的消息回溯

VPS

jump

Authentication vs Authorization

验证身份 vs 权限管理

Aspect	Authentication	Authorization
Definition	Verifies who you are.	Determines what you can do.
Focus	Identity.	Permissions and access control.
Timing	Happens before authorization.	Happens after authentication.
Input	Credentials (e.g., username/password).	Identity and rules/policies.
Output	Identity verification (authenticated user).	Access rights and privileges.
Examples	Login form, biometric scan.	Admin rights, file read/write access.