架构设计

本应用采用多进程架构，确保主进程与渲染进程职责分离，提升系统稳定性与安全性。主进程负责核心逻辑处理和数据获取，而渲染进程专注于用户界面展示与交互响应。

Main Process (主进程)
├── GitCodeApp (应用主类)
├── HttpService (HTTP请求服务)
└── GitCodeService (GitCode API服务)

Renderer Process (渲染进程)
└── GitCodeRenderer (前端渲染控制器)

在整体数据流动方面，系统通过明确的数据流向控制机制实现高效通信。数据从 GitCode API 获取后，经由主进程处理并传递至渲染层，最终呈现在用户界面上，形成闭环的数据流转路径。

GitCode API → HttpService → GitCodeService → IPC → Renderer → UI

核心技术实现

IPC 通信机制

为了实现主进程与渲染进程之间的安全通信，项目使用 Electron 提供的 IPC（Inter-Process Communication）机制，并结合 contextBridge 进行接口暴露，防止直接访问 Node.js API 带来的安全隐患。

在主进程中注册对应的 IPC 处理函数：

// main.js:132-138
ipcMain.handle('gitcode-get-events', async (event, username) => {
    return await this.gitCodeService.getUserEvents(username);
});
ipcMain.handle('gitcode-get-auth-events', async (event) => {
    return await this.gitCodeService.getAuthenticatedUserEvents();
});

预加载脚本中通过 contextBridge 向渲染进程暴露安全接口：

// preload.js
contextBridge.exposeInMainWorld('electronAPI', {
    gitCode: {
        getEvents: (username) => ipcRenderer.invoke('gitcode-get-events', username),
        getAuthEvents: () => ipcRenderer.invoke('gitcode-get-auth-events'),
    }
});

数据处理与转换

针对 GitCode 平台返回的特有事件结构，前端需进行标准化处理，以便统一渲染逻辑。

将原始数据中的多层级日期分组结构扁平化为单一事件列表，并补充类型标识与仓库信息：

// renderer.js:158-180
processGitCodeEvents(data) {
    if (!data || !data.events) {
        return [];
    }
    const allEvents = [];
    for (const date in data.events) {
        if (data.events.hasOwnProperty(date)) {
            const eventsOnDate = data.events[date];
            eventsOnDate.forEach(event => {
                allEvents.push({
                    ...event,
                    type: this.mapActionToEventType(event.action, event.action_name),
                    created_at: event.created_at,
                    repo: {
                        name: event.project_name
                    }
                });
            });
        }
    }
    return allEvents.sort((a, b) => new Date(b.created_at) - new Date(a.created_at));
}

根据不同的操作码或动作名称映射为标准事件类型，便于后续分类展示：

// renderer.js:182-200
mapActionToEventType(action, actionName) {
    const actionMap = {
        5: 'PushEvent',        // 推送代码
        'pushed to': 'PushEvent',
        27: 'WatchEvent',      // Star 项目
        'star': 'WatchEvent',
        1: 'CreateEvent',      // 创建项目
        'created': 'CreateEvent',
        2: 'ForkEvent',        // Fork 项目
        'forked': 'ForkEvent',
        // ... 更多映射
    };
    return actionMap[action] || actionMap[actionName] || 'UnknownEvent';
}

时间线渲染系统

为实现清晰的时间线展示效果，系统对已排序的事件按日期进行重新分组，便于以“日”为单位组织内容布局。

// renderer.js:378-390
groupEventsByDate(events) {
    const groups = {};
    events.forEach(event => {
        const eventDate = new Date(event.created_at).toISOString().split('T')[0];
        if (!groups[eventDate]) {
            groups[eventDate] = [];
        }
        groups[eventDate].push(event);
    });
    return groups;
}

同时，提供动态时间格式化功能，将 ISO 格式的时间戳转换为更友好的相对时间描述（如“今天”、“昨天”等），增强可读性：

// renderer.js:580-595
formatTime(dateString) {
    const date = new Date(dateString);
    const now = new Date();

概述

本文详细剖析基于 Electron 构建的鸿蒙 PC 端 GitCode 个人中心应用中的“个人动态”模块。该模块实现了用户活动记录的获取、过滤、分类及可视化展示功能，涵盖代码推送、项目收藏、创建与 Fork 等多种行为类型，构建完整的用户行为时间轴。

filterActivities() {
    if (!this.allEvents) return;
    const filteredEvents = this.eventsFilter === 'all'
        ? this.allEvents
        : this.allEvents.filter(event => event.type === this.eventsFilter);
    this.renderActivities(filteredEvents);
}

UI 过滤控件

<select id="event-type-filter">
    <option value="all">所有类型</option>
    <option value="PushEvent">推送事件</option>
    <option value="WatchEvent">Star 事件</option>
    <option value="CreateEvent">创建事件</option>
    <option value="ForkEvent">Fork 事件</option>
    <option value="IssuesEvent">Issues 事件</option>
    <option value="IssueCommentEvent">Issue 评论</option>
    <option value="PullRequestEvent">Pull Request</option>
</select>

5. 事件渲染引擎

事件项模板生成

renderEventItem(event) {
    const eventType = event.type;
    const eventTime = this.formatTime(event.created_at);
    const eventClass = this.getEventClass(eventType);
    const eventIcon = this.getEventIcon(eventType);
    const eventDescription = this.getEventDescription(event);
    return `
    <div class="timeline-item ${eventClass}" data-type="${eventType}">
        <div class="timeline-content">
            <div class="timeline-header">
                <div class="event-icon">
                    <i class="${eventIcon}"></i>
                </div>
                <span class="event-type">${this.getEventTypeText(event)}</span>
                <span class="event-time">${eventTime}</span>
            </div>
            <div class="timeline-body">
                <div class="event-repo">
                    ${this.escapeHtml(event.project_name || '未知项目')}
                </div>
                <div class="event-description">
                    ${eventDescription}
                </div>
            </div>
        </div>
    </div>`;
}

性能优化策略

为了提升系统响应速度和用户体验，采用了多种性能优化手段，确保在高频率数据请求场景下依然保持流畅。

1. 数据缓存机制

通过引入内存缓存，减少重复的网络请求，有效降低服务器负载并加快数据读取速度。

constructor(httpService) {
  this.httpService = httpService;
  this.baseURL = 'https://api.gitcode.com/api/v5';
  this.accessToken = null;
  this.cache = new Map();  // 使用Map实现内存缓存
}

在获取用户事件时优先检查缓存是否存在对应数据：

async getUserEvents(username) {
  const cacheKey = `events_${username}`;
  if (this.cache.has(cacheKey)) {
    return this.cache.get(cacheKey);  // 缓存命中直接返回
  }
  // ... 执行API调用逻辑
}

2. 懒加载机制

页面标签页内容采用懒加载策略，仅在用户首次点击切换时才触发数据加载，避免初始加载过多资源。

setupTabNavigation() {
  const navItems = document.querySelectorAll('.nav-item');
  navItems.forEach(item => {
    item.addEventListener('click', () => {
      // 判断是否已加载过该标签页数据
      if (!item.dataset.loaded) {
        this.loadTabData(item.dataset.tab);
        item.dataset.loaded = 'true';  // 标记为已加载
      }
    });
  });
}

3. 批量数据加载

对于多个独立但同时需要的数据源，使用并行请求策略提高整体加载效率。

async loadAllData() {
  if (!this.currentUser) return;
  const promises = [
    this.loadActivities(),
    this.loadStarredRepos(),
    this.loadWatchingRepos(),
    this.loadNamespaces()
  ];
  await Promise.all(promises);  // 并发执行所有请求
  this.updateOverview();
}

推送事件特殊处理

针对代码推送类事件进行结构化描述渲染，增强信息可读性。

// renderer.js:485-505
getPushEventDescription(event) {
  const pushData = event.push_data;
  if (!pushData) {
    return '推送了代码更新';
  }
  let html = '';
  if (pushData.ref_type === 'branch') {
    html += `推送到分支 <strong>${pushData.ref}</strong>`;
  }
  if (pushData.commit_count > 0) {
    html += `，包含 <strong>${pushData.commit_count}</strong> 个提交`;
  }
  if (pushData.commit_title) {
    html += `<div class="commit-message">${this.escapeHtml(pushData.commit_title)}</div>`;
  }
  return html || '推送了代码更新';
}

安全性考虑

1. XSS 防护

对可能包含恶意脚本的用户输入内容进行HTML实体转义，防止跨站脚本攻击（XSS）。

escapeHtml(unsafe) {
  if (!unsafe) return '';
  return unsafe
    .replace(/&/g, "&")
    .replace(/</g, "&lt;")
    .replace(/>/g, "&gt;")
    .replace(/"/g, "&quot;")
    .replace(/'/g, "&#039;");
}

2. Token 安全存储

访问令牌通过Electron API及本地存储双重机制保存，确保认证信息持久化的同时兼顾安全控制。

async saveAccessToken() {
  const token = tokenInput.value.trim();
  try {
    await window.electronAPI.gitCode.setToken(token);
    this.accessToken = token;
    localStorage.setItem('gitcode_access_token', token);  // 存储至浏览器本地
  } catch (error) {
    console.error('Token保存失败:', error);
  }
}

用户体验优化

加载状态管理

通过以下方法控制页面加载时的视觉反馈：

showLoading() {
  document.getElementById('loading-overlay').classList.add('active');
}

hideLoading() {
  document.getElementById('loading-overlay').classList.remove('active');
}

消息提示系统

实现了一个轻量级的 toast 提示功能，支持多种类型的消息展示：

showToast(message, type = 'info') {
  const container = document.getElementById('toast-container');
  const toast = document.createElement('div');
  toast.className = `toast ${type}`;
  const icon = type === 'success' ? 'fa-check-circle' :
               type === 'error' ? 'fa-exclamation-circle' :
               type === 'warning' ? 'fa-exclamation-triangle' : 'fa-info-circle';
  toast.innerHTML = `
  <i class="fas ${icon}"></i>
  <span>${message}</span>
  `;
  container.appendChild(toast);
  setTimeout(() => {
    toast.remove();  // 3秒后自动移除提示
  }, 3000);
}

扩展性设计

模块化架构

• HttpService：提供通用的 HTTP 请求封装
• GitCodeService：针对 GitCode 平台 API 的专用接口封装
• GitCodeRenderer：负责前端界面渲染与交互逻辑控制

事件系统

支持灵活扩展新事件类型，便于未来功能迭代：

// 可动态添加新的事件映射
const actionMap = {
  // 已有映射...
  'new_event_type': 'NewEventType',  // 新增自定义事件
};

主题系统

使用 CSS 自定义变量实现可切换的主题风格：

/* styles.css:10-21 */
:root {
  --primary-color: #2188ff;
  --secondary-color: #6c757d;
  --success-color: #28a745;
  --danger-color: #dc3545;
  /* 支持后续的主题切换机制 */
}

项目工程截图

鸿蒙平台相关项目结构展示：

Electron 工程目录结构示意图：

核心封装代码实现截图：

总结

个人动态模块充分体现了 Electron 在鸿蒙 PC 应用开发中的最佳实践，具备以下特点：

• 架构清晰：主进程与渲染进程职责分明，通信高效稳定
• 性能优化：采用缓存策略、懒加载机制及并行请求提升响应速度
• 用户体验：集成加载状态指示、友好消息提示和人性化时间格式化处理
• 安全可靠：实施 XSS 防护措施，并确保 Token 安全存储
• 扩展性强：采用模块化设计，配合事件系统，便于后续功能拓展