当前位置： 首页 > news >正文

微前端面试题及详细答案 88道（09-18）-- 核心原理与实现方式

news 2025/9/17 14:21:37

《前后端面试题》专栏集合了前后端各个知识模块的面试题，包括html，javascript，css，vue，react，java，Openlayers，leaflet，cesium，mapboxGL，threejs，nodejs，mangoDB，SQL，Linux… 。

前后端面试题-专栏总目录

在这里插入图片描述

文章目录

  • 一、本文面试题目录
      • 9. 微前端的实现通常涉及哪些关键技术点？
      • 10. 微前端中如何实现应用的加载与卸载？
      • 11. 什么是应用隔离？微前端如何保证应用间的隔离性？
      • 12. 微前端中的样式隔离有哪些实现方式？各有什么优缺点？
      • 13. 微前端中的JavaScript隔离是如何实现的？（如沙箱机制）
      • 14. 微前端中的路由系统如何设计？如何实现路由分发与匹配？
      • 15. 微前端中如何处理应用间的依赖共享（如共享React、Vue等库）？
      • 16. 什么是“基座应用”和“子应用”？它们的职责分别是什么？
      • 17. 微前端中应用的注册与发现机制是怎样的？
      • 18. 微前端如何实现应用的预加载？
  • 二、88道微前端面试题目录列表

一、本文面试题目录

9. 微前端的实现通常涉及哪些关键技术点？

微前端的实现需要解决多个核心技术问题，主要包括以下关键技术点：

  1. 应用加载与卸载
    动态加载子应用的资源（JS/CSS），并在路由切换时完成子应用的挂载与卸载，确保资源按需加载。

  2. 应用隔离

    • JS隔离：通过沙箱机制限制子应用对全局环境的访问和修改，避免污染。
    • CSS隔离：防止子应用样式影响基座或其他子应用，常用Shadow DOM或CSS命名空间。

  3. 路由管理
    基座应用统一管理路由，根据URL匹配规则分发到对应的子应用，同时支持子应用内部路由。

  4. 应用通信
    设计跨应用通信机制（如发布-订阅、全局状态共享），实现基座与子应用、子应用间的数据传递。

  5. 依赖共享
    提取公共依赖（如React、Vue）由基座共享，避免子应用重复加载，优化性能。

  6. 应用注册与发现
    子应用通过配置或接口注册到基座，基座动态感知子应用的新增或移除。

  7. 预加载策略
    提前加载可能需要的子应用资源，减少用户操作时的等待时间。

  8. 工程化支持
    实现子应用的独立构建、部署和版本管理，适配CI/CD流程。

这些技术点相互配合，共同支撑起微前端架构的核心能力。

10. 微前端中如何实现应用的加载与卸载？

应用加载流程：

  1. 路由匹配：基座应用监听路由变化，根据activeRule（激活规则）匹配对应的子应用。
  2. 资源加载：通过<script>和<link>标签动态加载子应用的入口JS和CSS。
  3. 生命周期初始化：执行子应用暴露的bootstrap方法（初始化一次）。
  4. 应用挂载：执行mount方法，将子应用渲染到基座的指定容器中。

应用卸载流程：

  1. 路由切换触发：当路由离开当前子应用的activeRule范围时，触发卸载。
  2. 资源清理：执行子应用的unmount方法，清理DOM、事件监听、定时器等。
  3. 沙箱重置：若开启沙箱，重置JS和CSS隔离环境，避免影响下一个子应用。

示例代码（Qiankun框架）：

// 子应用需暴露的生命周期方法
export async function bootstrap() {// 初始化操作（如创建Vue/React实例）console.log('子应用初始化');
}export async function mount(props) {// 挂载应用到基座提供的容器ReactDOM.render(<App />, props.container.querySelector('#root'));
}export async function unmount(props) {// 卸载应用并清理资源ReactDOM.unmountComponentAtNode(props.container.querySelector('#root'));// 清理定时器clearInterval(window.timer);
}// 基座应用注册子应用
registerMicroApps([{name: 'react-app',entry: '//localhost:3000', // 子应用入口container: '#micro-app-container', // 挂载容器activeRule: '/react' // 路由匹配规则}
]);

原理说明：
加载时通过动态插入资源标签获取子应用代码，利用JS沙箱执行代码避免全局污染；卸载时通过生命周期钩子确保资源彻底清理，防止内存泄漏。

11. 什么是应用隔离？微前端如何保证应用间的隔离性？

应用隔离是指在微前端架构中，确保各个子应用之间、子应用与基座应用之间相互独立，不会因代码冲突（如变量污染、样式覆盖）影响彼此的运行。

微前端保证隔离性的核心手段：

  1. JavaScript隔离
    通过沙箱机制限制子应用对全局环境（如window、document）的访问和修改：

    • 快照沙箱：记录子应用挂载前的全局状态，卸载时恢复（适合单实例场景）。
    • 代理沙箱：用Proxy代理window，子应用的操作仅作用于代理对象，不影响真实全局环境（适合多实例场景）。

  2. CSS隔离
    防止子应用样式污染全局或被其他应用污染：

    • Shadow DOM：将子应用DOM挂载到Shadow DOM中，其样式仅作用于内部。
    • CSS命名空间：强制子应用样式使用特定前缀（如BEM规范）。
    • 动态样式表切换：子应用卸载时移除其样式表。

  3. DOM隔离
    每个子应用有独立的挂载容器（如<div id="micro-app-vue">），避免DOM操作冲突。

示例（Qiankun隔离配置）：

// 基座应用配置强隔离
start({sandbox: {strictStyleIsolation: true, // 启用Shadow DOM样式隔离experimentalStyleIsolation: false // 禁用CSS前缀隔离（二选一）}
});

原理说明：
隔离的核心是通过技术手段划定子应用的"边界"，限制其对外部环境的影响范围，同时阻止外部环境干扰子应用，确保多应用共存时的稳定性。

12. 微前端中的样式隔离有哪些实现方式？各有什么优缺点？

微前端的样式隔离主要有以下实现方式：

方式实现原理优点缺点
Shadow DOM将子应用DOM挂载到Shadow DOM中，样式被封装在内部，不影响外部1. 彻底隔离，无样式冲突
2. 符合Web标准		1. 子应用无法使用全局样式（如主题）
2. 部分第三方组件库不兼容
CSS Modules构建时为CSS类名添加哈希前缀，确保类名唯一1. 实现简单，兼容性好
2. 支持局部与全局样式混合		1. 需侵入子应用代码（修改类名引用）
2. 第三方库样式可能仍冲突
BEM命名规范强制类名格式为block__element--modifier，通过命名空间隔离1. 无技术成本，易于理解
2. 兼容所有场景		1. 依赖团队规范执行，易出错
2. 类名冗长，开发体验差
动态样式表管理子应用挂载时加载样式表，卸载时移除1. 实现简单，无侵入性
2. 支持全局样式共享		1. 切换瞬间可能出现样式闪烁
2. 无法解决同页面多应用冲突
CSS-in-JS样式通过JS注入，自动生成唯一类名1. 彻底隔离，无冲突
2. 支持动态样式		1. 增加JS体积，影响性能
2. 学习成本高

示例（Shadow DOM实现）：

// 基座应用创建Shadow DOM容器
const container = document.getElementById('app-container');
const shadowRoot = container.attachShadow({ mode: 'open' });// 子应用挂载到Shadow DOM
function mountApp(html) {shadowRoot.innerHTML = html; // 子应用样式仅作用于shadowRoot内部
}

选择建议：

  • 追求彻底隔离且无全局样式依赖：优先选Shadow DOM。
  • 需兼容第三方库或全局样式：可采用CSS Modules + BEM组合方案。
  • 简单场景：动态样式表管理更轻量。

13. 微前端中的JavaScript隔离是如何实现的？（如沙箱机制）

微前端的JavaScript隔离主要通过沙箱机制实现，核心是限制子应用对全局环境（window、document等）的访问和修改，避免污染基座或其他子应用。常见的沙箱实现方式有：

  1. 快照沙箱（Snapshot Sandbox）

    • 原理：
      1. 子应用挂载前，记录全局状态（window属性、document事件等）的快照。
      2. 子应用运行时的修改仅作用于当前快照。
      3. 子应用卸载时，恢复原始快照，清除修改。
    • 适用场景：单实例子应用（同一时间只有一个子应用运行）。
    class SnapshotSandbox {constructor() {this.snapshot = {};this.modifyMap = {};}active() {// 记录初始快照this.snapshot = { ...window };}inactive() {// 恢复快照，保存修改for (const key in window) {if (window[key] !== this.snapshot[key]) {this.modifyMap[key] = window[key];window[key] = this.snapshot[key]; // 恢复原始值}}}
}

  2. 代理沙箱（Proxy Sandbox）

    • 原理：
      1. 用Proxy创建window的代理对象，子应用的所有操作都通过代理执行。
      2. 子应用读取属性时，优先从代理缓存获取，不存在则读取真实window。
      3. 子应用修改属性时，仅更新代理缓存，不影响真实window。
    • 适用场景：多实例子应用（同一时间运行多个子应用）。
    class ProxySandbox {constructor() {this.proxy = null;this.cache = new Map(); // 存储子应用的修改}active() {this.proxy = new Proxy(window, {get: (target, key) => this.cache.has(key) ? this.cache.get(key) : target[key],set: (target, key, value) => {this.cache.set(key, value); // 仅修改缓存return true;}});// 子应用代码通过this.proxy执行}inactive() {this.cache.clear(); // 卸载时清空缓存}
}

  3. VM沙箱（VM Sandbox）

    • 原理：利用Node.js的vm模块或浏览器的iframe创建独立执行环境，子应用在隔离的全局作用域中运行。
    • 特点：隔离性最强，但性能损耗较大，且与主环境通信成本高。

Qiankun中的沙箱选择：

  • 单实例场景默认使用快照沙箱，多实例场景自动切换为代理沙箱，兼顾性能与隔离性。

14. 微前端中的路由系统如何设计？如何实现路由分发与匹配？

微前端的路由系统需实现基座路由与子应用路由的协同，确保用户在不同子应用间切换时体验流畅。

设计原则：

  1. 基座主导路由分发：基座应用作为路由入口，负责匹配子应用；子应用管理内部路由。
  2. 路由隔离：子应用路由变化不影响基座或其他子应用。
  3. URL一致性：URL需反映当前子应用及内部页面状态，支持刷新和前进/后退。

实现方案：

  1. 路由结构设计
    采用嵌套路由格式：基座路由前缀/子应用标识/子应用内部路由
    示例：/admin/user/list 中，/admin是基座路由，user是子应用标识，/list是子应用内部路由。

  2. 路由分发流程

    • 基座应用监听hashchange或popstate事件，解析URL。
    • 根据预定义的activeRule（如/react、/vue）匹配对应的子应用。
    • 若匹配成功，加载并挂载子应用，同时将子应用内部路由传递给它。
    • 子应用根据内部路由渲染对应页面。

  3. 实现代码示例

    // 基座应用路由配置（基于React Router）
import { BrowserRouter, Routes, Route } from 'react-router-dom';
import MicroAppContainer from './MicroAppContainer';function App() {return (<BrowserRouter><Routes>{/* 基座自身路由 */}<Route path="/" element={<Home />} />{/* 子应用路由分发 */}<Route path="/react/*" element={<MicroAppContainer appName="react-app" />} /><Route path="/vue/*" element={<MicroAppContainer appName="vue-app" />} /></Routes></BrowserRouter>);
}// 子应用（React）路由配置
function App() {return (<Routes><Route path="/" element={<ReactHome />} /><Route path="/detail" element={<ReactDetail />} /></Routes>);
}

路由匹配关键逻辑：

// 基座应用匹配子应用
function matchMicroApp(pathname) {const microApps = [{ name: 'react-app', activeRule: '/react' },{ name: 'vue-app', activeRule: '/vue' }];return microApps.find(app => pathname.startsWith(app.activeRule));
}// 监听路由变化
window.addEventListener('popstate', () => {const app = matchMicroApp(window.location.pathname);if (app) {mountMicroApp(app.name); // 挂载匹配的子应用}
});

原理说明：
基座通过路由前缀匹配子应用，子应用内部路由通过通配符（如/*）传递，实现"基座管分发，子应用管内部"的协同模式，同时保持URL与页面状态的一致性。

15. 微前端中如何处理应用间的依赖共享（如共享React、Vue等库）？

微前端中处理依赖共享的核心目标是避免重复加载公共库（如React、Vue、Lodash），减少资源体积和加载时间。常见方案如下：

  1. 基座共享 + 子应用排除

    • 原理：基座应用全局引入公共依赖，子应用通过构建配置排除这些依赖，运行时从全局获取。
    • 实现步骤：
      1. 基座应用加载公共库并暴露到window：
        <!-- 基座HTML -->
<script src="https://cdn.jsdelivr.net/npm/react@18/umd/react.production.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/react-dom@18/umd/react-dom.production.min.js"></script>
      2. 子应用通过webpack.externals排除依赖：
        // 子应用webpack.config.js
module.exports = {externals: {react: 'React', // 映射到window.React'react-dom': 'ReactDOM'}
};

  2. 动态共享（模块联邦）

    • 原理：基于Webpack的Module Federation，子应用可动态加载其他应用暴露的依赖，无需基座提前引入。
    • 示例：
      // 共享库应用的webpack配置
new ModuleFederationPlugin({name: 'sharedLibs',exposes: { './react': 'react', './react-dom': 'react-dom' },filename: 'remoteEntry.js'
});// 子应用引入共享依赖
new ModuleFederationPlugin({remotes: { sharedLibs: 'sharedLibs@//localhost:3001/remoteEntry.js' }
});// 子应用代码中使用
import React from 'sharedLibs/react';

  3. 预加载共享依赖

    • 原理：基座应用在启动时预加载公共依赖，子应用通过动态导入使用，避免重复请求。
    • 示例：
      // 基座预加载
window.sharedDeps = {react: () => import('react'),'react-dom': () => import('react-dom')
};// 子应用使用
const React = await window.sharedDeps.react();

方案对比：

方案优点缺点适用场景
基座共享实现简单，兼容性好依赖版本固定，不支持子应用自定义版本团队技术栈统一，版本兼容
模块联邦动态共享，版本灵活配置复杂，依赖Webpack子应用技术栈多样，版本差异大
预加载共享按需加载，性能优需要手动管理依赖加载顺序对性能要求高的场景

最佳实践：
优先采用"基座共享 + 子应用排除"方案，对于版本差异大的场景，可结合模块联邦实现部分依赖的独立加载。

16. 什么是“基座应用”和“子应用”？它们的职责分别是什么？

在微前端架构中，应用被划分为基座应用（主应用） 和子应用（微应用） 两类，各自承担不同职责：

基座应用（Host Application）

  • 定义：整个微前端系统的入口和核心控制层，负责整合所有子应用。
  • 核心职责：
    1. 子应用管理：注册、加载、挂载、卸载子应用，维护子应用生命周期。
    2. 路由分发：监听URL变化，根据路由规则匹配并激活对应的子应用。
    3. 通信中枢：提供跨应用通信机制（如全局状态、事件总线）。
    4. 资源共享：管理公共依赖（如React、Vue）、全局样式和工具函数。
    5. 全局控制：统一处理认证授权、错误监控、日志收集等横切关注点。

示例（基座应用核心代码）：

// 基座应用初始化
import { registerMicroApps, start } from 'qiankun';// 注册子应用
registerMicroApps([{name: 'app1', // 子应用名称entry: '//localhost:8081', // 子应用入口container: '#app-container', // 挂载容器activeRule: '/app1', // 激活路由规则props: { token: 'xxx' } // 传递给子应用的参数}
]);// 启动基座
start({sandbox: { strictStyleIsolation: true } // 配置隔离策略
});

子应用（Micro Application）

  • 定义：独立开发、部署的小型应用，负责实现具体业务功能（如商品列表、订单管理）。
  • 核心职责：
    1. 业务实现：专注于自身业务逻辑，与其他子应用解耦。
    2. 生命周期适配：暴露bootstrap、mount、unmount等生命周期方法，供基座调用。
    3. 资源隔离：通过样式隔离和JS沙箱避免影响其他应用。
    4. 通信适配：通过基座提供的API与其他应用或基座通信。
    5. 独立运行：支持单独启动和调试，不依赖基座环境。

示例（子应用生命周期）：

// 子应用暴露生命周期
export async function bootstrap() {// 初始化操作（仅执行一次）console.log('子应用初始化');
}export async function mount(props) {// 挂载应用到容器renderApp(props.container);// 监听基座通信props.onGlobalStateChange((state) => console.log('全局状态变化', state));
}export async function unmount() {// 卸载应用并清理资源unmountApp();
}

关系说明：
基座应用是"管理者"，负责协调各子应用；子应用是"执行者"，专注于业务实现。二者通过预定义的协议（如生命周期、通信API）协作，实现"整体统一，局部独立"的架构目标。

17. 微前端中应用的注册与发现机制是怎样的？

微前端的应用注册与发现是指子应用如何被基座应用识别和管理的过程，确保基座能动态感知子应用的存在并正确加载。常见机制有：

  1. 静态注册

    • 原理：在基座应用中通过配置文件手动注册子应用信息（如名称、入口、路由规则），启动时加载配置。
    • 实现示例：
      // 基座应用静态配置
const microApps = [{name: 'vue-app',entry: '//localhost:8080',activeRule: '/vue',container: '#container'},{name: 'react-app',entry: '//localhost:3000',activeRule: '/react'}
];// 注册到基座
registerMicroApps(microApps);
    • 优点：实现简单，适合子应用数量固定的场景。
    • 缺点：子应用增减需修改基座代码，灵活性低。

  2. 动态注册（配置中心）

    • 原理：子应用信息存储在配置中心（如Nacos、Apollo）或后端接口，基座启动时动态拉取并注册。
    • 实现示例：
      // 基座从接口动态获取子应用配置
async function registerAppsFromServer() {const response = await fetch('/api/micro-apps');const microApps = await response.json();registerMicroApps(microApps); // 动态注册
}// 启动时执行
registerAppsFromServer().then(() => start());
    • 优点：子应用增减无需修改基座，支持动态扩展。
    • 缺点：依赖配置中心，增加系统复杂度。

  3. 自动发现（服务发现）

    • 原理：子应用部署后主动向注册中心注册，基座通过注册中心实时发现可用子应用。
    • 实现流程：
      1. 子应用部署时调用注册中心API（如/register?name=app1&entry=xxx）。
      2. 基座定期轮询注册中心获取最新子应用列表。
      3. 基座根据子应用状态（在线/离线）动态更新注册信息。
    • 优点：完全自动化，适合大规模微前端系统。
    • 缺点：需实现注册中心和健康检查机制，成本较高。

核心信息要素：
无论哪种机制，子应用需提供的核心信息包括：

  • name：唯一标识
  • entry：资源入口（HTML/JS地址）
  • activeRule：路由匹配规则
  • container：挂载容器选择器
  • props：传递给子应用的初始化参数

Qiankun中的实现：
Qiankun默认支持静态注册，通过registerMicroApps方法注册；动态注册可结合后端接口实现，调用registerMicroApps前先异步获取配置即可。

18. 微前端如何实现应用的预加载？

微前端的预加载是指在用户需要访问子应用前，提前加载其资源（JS/CSS），以减少用户操作时的等待时间，提升体验。常见实现方式如下：

  1. 基于路由预测的预加载

    • 原理：根据当前路由和用户行为（如鼠标悬停、页面停留）预测可能访问的子应用，提前加载。
    • 示例（Qiankun预加载配置）：
      // 基座应用启动时配置预加载规则
start({prefetch: 'all' // 预加载所有子应用（默认值）// 可选值：// 'all'：预加载所有子应用// 'none'：不预加载// (apps) => apps.filter(...)：自定义预加载逻辑
});
    • 优化：仅预加载当前路由相邻的子应用（如同一模块下的相关应用），避免资源浪费。

  2. 空闲时间预加载

    • 原理：利用浏览器的requestIdleCallback API，在主线程空闲时加载子应用资源。
    • 实现示例：
      // 自定义预加载逻辑
function preloadMicroAppsWhenIdle(apps) {// 筛选需要预加载的子应用const needPreloadApps = apps.filter(app => app.name !== currentAppName);// 空闲时加载requestIdleCallback(() => {needPreloadApps.forEach(app => {// 加载子应用入口HTML（提取JS/CSS）fetch(app.entry).then(res => res.text()).then(html => {extractAndLoadResources(html); // 提取并预加载资源});});});
}// 注册时应用自定义逻辑
start({prefetch: preloadMicroAppsWhenIdle
});

  3. 可视区域预加载

    • 原理：当子应用的入口（如导航菜单）进入可视区域时，预加载其资源。
    • 实现示例：
      // 监听导航项可见性
const observer = new IntersectionObserver((entries) => {entries.forEach(entry => {if (entry.isIntersecting) {const appName = entry.target.dataset.app;preloadApp(appName); // 预加载对应子应用observer.unobserve(entry.target);}});
});// 监听所有导航项
document.querySelectorAll('.nav-item').forEach(item => {observer.observe(item);
});

  4. 预加载资源缓存

    • 原理：预加载的资源会被浏览器缓存，子应用实际挂载时直接从缓存读取，无需重新请求。
    • 验证：通过link标签的rel="prefetch"或rel="preload"提示浏览器缓存资源：
      <!-- 预加载子应用JS -->
<link rel="prefetch" href="http://localhost:3000/main.js" as="script">

预加载策略选择：

  • 小型应用：使用Qiankun默认的prefetch: 'all'简单高效。
  • 大型应用：结合路由预测和空闲时间加载，平衡性能与资源消耗。
  • 移动端：慎用全量预加载，优先基于用户行为触发预加载，避免占用过多带宽。

注意事项：
预加载可能增加初始带宽消耗，需根据应用规模和用户网络环境动态调整策略，避免负面影响。

二、88道微前端面试题目录列表

文章序号微前端面试题88道
1微前端面试题及详细答案88道（01-08）
2微前端面试题及详细答案88道（09-18）
3微前端面试题及详细答案88道（19-35）
4微前端面试题及详细答案88道（36-43）
5微前端面试题及详细答案88道（44-60）
6微前端面试题及详细答案88道（61-73）
7微前端面试题及详细答案88道（74-88）

文章转载自：

http://doDFi4Ne.dnbhd.cn
http://oFdNTGLQ.dnbhd.cn
http://bI1DsIE3.dnbhd.cn
http://vsZA4LrX.dnbhd.cn
http://PsHfMTXg.dnbhd.cn
http://xINw3kMQ.dnbhd.cn
http://7iEqdJpc.dnbhd.cn
http://4pSwCNfo.dnbhd.cn
http://mxYjxLao.dnbhd.cn
http://OCB3pLDu.dnbhd.cn
http://66rf7qvs.dnbhd.cn
http://48epaEXa.dnbhd.cn
http://AjEoLbIh.dnbhd.cn
http://WirGcFc1.dnbhd.cn
http://ExQLbYbc.dnbhd.cn
http://o8BbHcD5.dnbhd.cn
http://jP7FgxG8.dnbhd.cn
http://sxpLWRRl.dnbhd.cn
http://ihhKYdb0.dnbhd.cn
http://u2L3JMfS.dnbhd.cn
http://cP8JwRyP.dnbhd.cn
http://GReZU21W.dnbhd.cn
http://Wta6hF9c.dnbhd.cn
http://6IEbXQPk.dnbhd.cn
http://qT7N7cpB.dnbhd.cn
http://2mG9MqmG.dnbhd.cn
http://ybpiNIle.dnbhd.cn
http://IPodoI39.dnbhd.cn
http://oDj4z5ou.dnbhd.cn
http://lpwsw3nq.dnbhd.cn
http://www.dtcms.com/a/387095.html

相关文章：

  • VBA技术资料MF362：将窗体控件添加到字典
  • 【Leetcode】高频SQL基础题--1321.餐馆营业额变化增长
  • Redis 中 Intset 的内存结构与存储机制详解
  • uniapp打包前端项目
  • cka解题思路1.32-3
  • 如何解决模型的过拟合问题？
  • 2025牛客周赛108场e题
  • 【课堂笔记】复变函数-2
  • 25、优化算法与正则化技术：深度学习的调优艺术
  • qt QCategoryAxis详解
  • 云游戏时代，游戏盾如何保障新型业务的流畅体验
  • 【Block总结】LRSA，用于语义分割的低分辨率自注意力|TPAMI 2025
  • PY32MD310单片机介绍 电机控制专用，内置三相半桥栅极驱动器
  • Ubuntu服务器挖矿病毒清理
  • 【数据结构】——二叉树
  • 《怪物猎人 荒野》总整理：预载和开放时间、登场怪物
  • web服务解析案例
  • 莫烦Python基础笔记（部分）
  • ACP（四）：RAG工作流程及如何创建一个RAG应用
  • qgis导入cad怎么做？
  • 在线图书借阅平台的设计与实现 —— 基于飞算JavaAI的实战开发全流程与优化实践（架构设计与核心模块开发）
  • Spring Cloud - 面试知识点（服务雪崩）
  • 【JQ】使用JS在前端达到存储cookie的效果
  • Git企业开发--分支管理
  • LoRaWAN方案详解：2025年LoRaWAN技术创新与行业发展趋势
  • 【Leetcode hot 100】108.将有序数组转换为二叉搜索树
  • 打包数据集解析及大模型强化学习拓展阅读（96）
  • 软考-系统架构设计师 系统分析与设计详细讲解
  • 什么是信创产品？信创产品认证有哪些标准?
  • docker和虚拟机对比