基于Vue的前端翻译界面开发:Hunyuan-MT 7B全栈实战

想象一下,你手头有一个性能强悍的翻译大模型,比如腾讯开源的Hunyuan-MT-7B,它支持几十种语言互译,效果拔群。但它的交互界面可能只是一个简单的命令行,或者一个功能简陋的网页。怎么才能让这个“大脑”配上更聪明、更好用的“手脚”,变成一个用户愿意天天用的产品呢?

相关服务:日本服务器租用

这就是我们今天要聊的话题。我会带你一步步用Vue.js,为Hunyuan-MT-7B这个翻译模型,打造一个现代化、响应式的前端应用界面。我们不止是简单调用API,还会涉及工程搭建、用户体验优化、结果可视化,以及如何利用云平台快速部署这套前后端分离的架构。整个过程,就像给一位武林高手量身定制一套得心应手的兵器。

1. 为什么选择Vue.js来构建翻译前端?

在开始敲代码之前,我们得先想清楚工具选型。前端框架那么多,React、Angular、Svelte各有千秋,为什么我推荐Vue.js来做这个翻译应用?

首先,Vue的学习曲线相对平缓。它的模板语法很直观,对于需要快速上手、把主要精力放在业务逻辑(也就是如何跟翻译API打交道)上的开发者来说,非常友好。你不需要花太多时间去理解复杂的概念,就能构建出结构清晰的组件。

其次,Vue的响应式系统是它的核心魅力。翻译应用里有很多状态需要管理:用户输入的文字、选择的源语言和目标语言、翻译过程中的加载状态、历史记录列表、以及最终呈现的翻译结果。Vue能让你用非常声明式的方式去管理这些状态,数据一变,界面自动更新,省去了大量手动操作DOM的麻烦。

再者,Vue的生态系统足够成熟。我们需要用到的路由管理(Vue Router)、状态管理(Pinia)、HTTP客户端(Axios)、UI组件库(比如Element Plus或Vant)都有非常优秀的、与Vue深度集成的解决方案。这意味着我们不用重复造轮子,可以快速搭建出功能完善、界面美观的应用。

最后,从性能和维护角度考虑,Vue 3带来的Composition API让代码组织更加灵活,尤其是对于这种可能包含复杂交互逻辑的应用。我们可以把翻译相关的数据获取、状态管理、错误处理逻辑很好地封装成可复用的组合式函数,让代码既清晰又好维护。

所以,综合来看,Vue.js在易用性、效率、生态和现代开发体验之间取得了很好的平衡,是构建这类AI应用前端的绝佳选择。

2. 项目初始化与核心依赖配置

好了,理论说完,我们动手开干。首先,确保你的开发环境已经安装了Node.js(建议16.x或18.x LTS版本)和npm或yarn。

第一步,使用Vue官方的脚手架工具create-vue来快速生成项目骨架。打开终端,执行以下命令:

npm create vue@latest hunyuan-translator-frontend

命令行会交互式地询问你一些配置选项。对于我们的翻译应用,我建议这样选择:

  • TypeScript:选择“Yes”。类型检查能在开发阶段帮我们避免很多低级错误,尤其是与后端API交互时,定义清晰的接口类型非常重要。
  • JSX:选择“No”。我们使用Vue的单文件组件模板语法就够了。
  • Vue Router:选择“Yes”。虽然我们这个单页应用可能页面不多,但路由管理对于组织代码和未来扩展(比如增加“设置”页面、“历史记录”页面)很有帮助。
  • Pinia:选择“Yes”。这是Vue官方推荐的状态管理库,比Vuex更轻量、更符合Composition API的风格。我们将用它来集中管理翻译状态。
  • ESLint / Prettier:建议都选上,保持代码风格统一。

项目创建完成后,进入目录并安装一些我们马上要用到的核心依赖:

cd hunyuan-translator-frontend
npm install
# 安装UI组件库、HTTP客户端和图标库
npm install element-plus axios @element-plus/icons-vue
# 安装Pinia持久化插件,用于保存用户的历史记录到本地
npm install pinia-plugin-persistedstate

接下来,我们需要对项目进行一些基础配置。打开 src/main.ts 文件,全局引入Element Plus组件库和它的样式:

import { createApp } from 'vue'
import { createPinia } from 'pinia'
import piniaPluginPersistedstate from 'pinia-plugin-persistedstate'
import ElementPlus from 'element-plus'
import 'element-plus/dist/index.css'
import * as ElementPlusIconsVue from '@element-plus/icons-vue'

import App from './App.vue'
import router from './router'

const app = createApp(App)
const pinia = createPinia()
// 使用持久化插件
pinia.use(piniaPluginPersistedstate)

app.use(pinia)
app.use(router)
app.use(ElementPlus)
// 全局注册所有图标,方便在组件内使用
for (const [key, component] of Object.entries(ElementPlusIconsVue)) {
  app.component(key, component)
}

app.mount('#app')

然后,我们创建一个Axios实例,并配置好基础URL和拦截器。在 src 目录下新建一个 utils 文件夹,然后创建 request.ts 文件:

// src/utils/request.ts
import axios from 'axios'

// 创建axios实例,这里的基础URL需要替换成你实际部署的后端地址
// 例如,如果你在本地运行后端,可能是 'http://localhost:8021/v1'
const service = axios.create({
  baseURL: import.meta.env.VITE_API_BASE_URL || 'http://your-backend-server/v1',
  timeout: 30000, // 超时时间设为30秒,因为大模型推理可能需要一点时间
  headers: {
    'Content-Type': 'application/json',
  },
})

// 请求拦截器:可以在这里统一添加token等认证信息
service.interceptors.request.use(
  (config) => {
    // 假设你的后端API需要API Key,可以在这里设置
    // config.headers.Authorization = `Bearer ${your_api_key}`
    return config
  },
  (error) => {
    return Promise.reject(error)
  }
)

// 响应拦截器:统一处理错误
service.interceptors.response.use(
  (response) => {
    // 如果后端返回的数据结构是 { data: ..., code: 200 }
    // 可以在这里直接返回 response.data.data
    return response.data
  },
  (error) => {
    // 网络错误、超时、服务器错误等统一处理
    console.error('API请求错误:', error)
    let message = '翻译服务暂时不可用,请稍后重试。'
    if (error.response) {
      // 服务器返回了错误状态码
      switch (error.response.status) {
        case 400:
          message = '请求参数有误。'
          break
        case 401:
          message = '认证失败,请检查API Key。'
          break
        case 429:
          message = '请求过于频繁,请稍后再试。'
          break
        case 500:
          message = '服务器内部错误。'
          break
        default:
          message = `服务器错误 (${error.response.status})`
      }
    } else if (error.request) {
      // 请求已发出但没有收到响应
      message = '网络连接异常,请检查网络设置。'
    }
    // 这里可以触发一个全局的错误提示,我们稍后在状态管理里实现
    return Promise.reject(new Error(message))
  }
)

export default service

别忘了在项目根目录的 .env.development 和 .env.production 文件中配置环境变量,例如:

VITE_API_BASE_URL=http://localhost:8021/v1

这样,我们的项目骨架和基础工具就准备好了。

3. 使用Pinia构建翻译状态管理中心

在Vue 3的Composition API时代,Pinia成了状态管理的首选。它更简洁,和TypeScript配合得更好。对于翻译应用,我们需要一个中心化的地方来管理所有跟翻译相关的状态和逻辑。

在 src/stores 目录下,我们创建一个 translator.ts 文件:

// src/stores/translator.ts
import { defineStore } from 'pinia'
import { ref, computed } from 'vue'
import type { Ref } from 'vue'
import request from '@/utils/request'

// 定义翻译历史记录项的类型
export interface TranslationHistoryItem {
  id: string
  timestamp: number
  sourceText: string
  sourceLang: string
  targetLang: string
  translatedText: string
}

// 定义支持的语言类型,这里以Hunyuan-MT-7B支持的部分语言为例
export interface LanguageOption {
  code: string
  name: string
  nativeName?: string
}

export const useTranslatorStore = defineStore(
  'translator',
  () => {
    // --- 状态定义 ---
    // 用户输入的原文
    const sourceText: Ref<string> = ref('')
    // 选择的源语言代码
    const sourceLang: Ref<string> = ref('zh')
    // 选择的目标语言代码
    const targetLang: Ref<string> = ref('en')
    // 翻译结果
    const translatedText: Ref<string> = ref('')
    // 是否正在翻译中
    const isLoading: Ref<boolean> = ref(false)
    // 错误信息
    const error: Ref<string | null> = ref(null)
    // 翻译历史记录
    const history: Ref<TranslationHistoryItem[]> = ref([])

    // --- 计算属性 ---
    // 当前是否可以进行翻译(有原文且不正在加载)
    const canTranslate = computed(() => {
      return sourceText.value.trim().length > 0 && !isLoading.value
    })

    // 最近5条历史记录
    const recentHistory = computed(() => {
      return [...history.value]
        .sort((a, b) => b.timestamp - a.timestamp)
        .slice(0, 5)
    })

    // --- 支持的语言列表 ---
    // 这是一个简化版,Hunyuan-MT-7B实际支持33种语言
    const supportedLanguages: LanguageOption[] = [
      { code: 'zh', name: '中文', nativeName: '中文' },
      { code: 'en', name: '英语', nativeName: 'English' },
      { code: 'ja', name: '日语', nativeName: '日本語' },
      { code: 'ko', name: '韩语', nativeName: '한국어' },
      { code: 'fr', name: '法语', nativeName: 'Français' },
      { code: 'de', name: '德语', nativeName: 'Deutsch' },
      { code: 'es', name: '西班牙语', nativeName: 'Español' },
      { code: 'ru', name: '俄语', nativeName: 'Русский' },
      { code: 'ar', name: '阿拉伯语', nativeName: 'العربية' },
      { code: 'pt', name: '葡萄牙语', nativeName: 'Português' },
    ]

    // --- 动作(Actions) ---
    // 交换源语言和目标语言
    function swapLanguages() {
      const temp = sourceLang.value
      sourceLang.value = targetLang.value
      targetLang.value = temp
      // 如果已经有翻译结果,可以顺便交换原文和译文,方便快速回译
      if (translatedText.value) {
        const tempText = sourceText.value
        sourceText.value = translatedText.value
        translatedText.value = tempText
      }
    }

    // 执行翻译
    async function translate() {
      if (!canTranslate.value) return

      isLoading.value = true
      error.value = null

      try {
        // 调用后端API。这里假设后端是类似OpenAI API的格式。
        // Hunyuan-MT-7B部署后,通常会提供一个兼容OpenAI API的接口。
        const response = await request.post('/chat/completions', {
          model: 'Hunyuan-MT-7B', // 模型名称,根据你的后端配置调整
          messages: [
            {
              role: 'user',
              // 构建一个简单的翻译指令。你可以根据模型特性设计更复杂的prompt。
              content: `请将以下${getLanguageName(sourceLang.value)}文本翻译成${getLanguageName(targetLang.value)}:\n${sourceText.value}`,
            },
          ],
          temperature: 0.3, // 低温度使输出更确定,适合翻译任务
          max_tokens: 2048,
          stream: false, // 我们先实现非流式,后面可以升级为流式响应
        })

        // 解析响应,这里需要根据你后端返回的实际数据结构调整
        const translatedContent = response.choices?.[0]?.message?.content || ''
        translatedText.value = translatedContent.trim()

        // 翻译成功后,保存到历史记录
        addToHistory()
      } catch (err: any) {
        error.value = err.message || '翻译过程中发生未知错误。'
        console.error('翻译失败:', err)
      } finally {
        isLoading.value = false
      }
    }

    // 清空当前翻译内容
    function clearTranslation() {
      sourceText.value = ''
      translatedText.value = ''
      error.value = null
    }

    // 添加到历史记录
    function addToHistory() {
      if (!sourceText.value.trim() || !translatedText.value.trim()) return

      const historyItem: TranslationHistoryItem = {
        id: Date.now().toString(),
        timestamp: Date.now(),
        sourceText: sourceText.value,
        sourceLang: sourceLang.value,
        targetLang: targetLang.value,
        translatedText: translatedText.value,
      }

      history.value.unshift(historyItem) // 添加到开头
      // 历史记录太多可以限制一下,比如只保留最近50条
      if (history.value.length > 50) {
        history.value.pop()
      }
    }

    // 从历史记录中删除一项
    function removeFromHistory(id: string) {
      const index = history.value.findIndex(item => item.id === id)
      if (index > -1) {
        history.value.splice(index, 1)
      }
    }

    // 清空所有历史记录
    function clearAllHistory() {
      history.value = []
    }

    // 根据语言代码获取语言名称的辅助函数
    function getLanguageName(code: string): string {
      const lang = supportedLanguages.find(l => l.code === code)
      return lang?.name || code
    }

    // --- 暴露给组件使用 ---
    return {
      // 状态
      sourceText,
      sourceLang,
      targetLang,
      translatedText,
      isLoading,
      error,
      history,
      // 计算属性
      canTranslate,
      recentHistory,
      supportedLanguages,
      // 动作
      swapLanguages,
      translate,
      clearTranslation,
      addToHistory,
      removeFromHistory,
      clearAllHistory,
      getLanguageName,
    }
  },
  {
    // 配置持久化:将历史记录保存到localStorage
    persist: {
      paths: ['history'],
      storage: localStorage,
    },
  }
)

这个Store把翻译应用的核心逻辑都集中管理起来了:语言选择、文本输入、调用API、处理结果、保存历史。组件只需要调用这些暴露出来的函数和状态,界面就会自动更新,非常清晰。

4. 构建核心翻译界面组件

状态管理准备好了,现在我们来打造用户直接看到的界面。我们将创建一个主要的翻译页面组件。

基于Vue的前端翻译界面开发:Hunyuan-MT 7B全栈实战

在 src/views 目录下(如果你使用了Vue Router),创建 TranslatorView.vue 文件。如果没用Router,也可以在 src/components 下创建,然后在 App.vue 中引入。

<!-- src/views/TranslatorView.vue -->
<template>
  <div class="translator-container">
    <!-- 页面标题和简介 -->
    <div class="page-header">
      <h1><el-icon><Promotion /></el-icon> Hunyuan-MT-7B 智能翻译</h1>
      <p class="subtitle">基于腾讯混元轻量级翻译模型,支持多语言高精度互译</p>
    </div>

    <!-- 主翻译区域 -->
    <div class="main-translator">
      <!-- 语言选择和控制栏 -->
      <div class="language-controls">
        <div class="lang-selector">
          <el-select
            v-model="store.sourceLang"
            placeholder="选择源语言"
            size="large"
            style="width: 200px"
          >
            <el-option
              v-for="lang in store.supportedLanguages"
              :key="`src-${lang.code}`"
              :label="`${lang.name} (${lang.nativeName})`"
              :value="lang.code"
            />
          </el-select>
          <el-button
            :icon="Switch"
            circle
            size="large"
            @click="store.swapLanguages"
            :disabled="store.isLoading"
            class="swap-btn"
            title="交换语言"
          />
          <el-select
            v-model="store.targetLang"
            placeholder="选择目标语言"
            size="large"
            style="width: 200px"
          >
            <el-option
              v-for="lang in store.supportedLanguages"
              :key="`tgt-${lang.code}`"
              :label="`${lang.name} (${lang.nativeName})`"
              :value="lang.code"
            />
          </el-select>
        </div>

        <div class="action-buttons">
          <el-button
            type="primary"
            :icon="Promotion"
            size="large"
            @click="handleTranslate"
            :loading="store.isLoading"
            :disabled="!store.canTranslate"
          >
            {{ store.isLoading ? '翻译中...' : '开始翻译' }}
          </el-button>
          <el-button
            :icon="Delete"
            size="large"
            @click="store.clearTranslation"
            :disabled="!store.sourceText && !store.translatedText"
          >
            清空
          </el-button>
        </div>
      </div>

      <!-- 原文和译文编辑区域 -->
      <div class="translation-editor">
        <!-- 原文输入框 -->
        <div class="editor-panel source-panel">
          <div class="panel-header">
            <span class="lang-label">{{ getLangLabel(store.sourceLang) }}</span>
            <span class="char-count">{{ store.sourceText.length }} 字</span>
          </div>
          <el-input
            v-model="store.sourceText"
            type="textarea"
            :rows="10"
            placeholder="请输入要翻译的文本..."
            resize="none"
            :disabled="store.isLoading"
            @keydown.ctrl.enter="handleTranslate" <!-- 支持Ctrl+Enter快捷键翻译 -->
          />
          <div class="panel-footer">
            <el-button-group>
              <el-button :icon="Microphone" size="small" text>语音输入</el-button>
              <el-button :icon="Picture" size="small" text>图片翻译</el-button>
              <el-button :icon="Document" size="small" text>导入文件</el-button>
            </el-button-group>
          </div>
        </div>

        <!-- 中间的分隔箭头 -->
        <div class="editor-divider">
          <el-icon :size="24"><Right /></el-icon>
        </div>

        <!-- 译文显示区域 -->
        <div class="editor-panel target-panel">
          <div class="panel-header">
            <span class="lang-label">{{ getLangLabel(store.targetLang) }}</span>
            <div class="result-actions">
              <el-button
                :icon="CopyDocument"
                size="small"
                text
                @click="copyToClipboard(store.translatedText)"
                :disabled="!store.translatedText"
              >
                复制
              </el-button>
              <el-button
                :icon="Reading"
                size="small"
                text
                @click="speakText(store.translatedText)"
                :disabled="!store.translatedText"
              >
                朗读
              </el-button>
            </div>
          </div>
          <!-- 翻译结果展示 -->
          <div class="result-display" :class="{ 'is-loading': store.isLoading }">
            <div v-if="store.isLoading" class="loading-indicator">
              <el-icon class="loading-icon"><Loading /></el-icon>
              <span>模型正在努力翻译中...</span>
            </div>
            <div v-else-if="store.error" class="error-message">
              <el-icon><Warning /></el-icon>
              <span>{{ store.error }}</span>
            </div>
            <div v-else-if="store.translatedText" class="translated-text">
              {{ store.translatedText }}
            </div>
            <div v-else class="placeholder">
              <el-icon><ChatLineRound /></el-icon>
              <span>翻译结果将在这里显示</span>
            </div>
          </div>
          <div class="panel-footer">
            <el-rate
              v-model="rating"
              :max="5"
              allow-half
              show-score
              text-color="#ff9900"
              score-template="{value} 分"
              size="small"
              v-if="store.translatedText && !store.isLoading"
            />
          </div>
        </div>
      </div>
    </div>

    <!-- 历史记录侧边栏 -->
    <div class="history-sidebar" :class="{ 'is-collapsed': isHistoryCollapsed }">
      <div class="sidebar-header" @click="isHistoryCollapsed = !isHistoryCollapsed">
        <el-icon><Clock /></el-icon>
        <span>翻译历史</span>
        <el-icon class="collapse-icon">
          {{ isHistoryCollapsed ? ArrowLeft : ArrowRight }}
        </el-icon>
      </div>
      <div class="sidebar-content" v-if="!isHistoryCollapsed">
        <div v-if="store.recentHistory.length === 0" class="empty-history">
          <el-icon><Notebook /></el-icon>
          <p>暂无历史记录</p>
        </div>
        <div v-else class="history-list">
          <div
            v-for="item in store.recentHistory"
            :key="item.id"
            class="history-item"
            @click="loadHistoryItem(item)"
          >
            <div class="history-item-header">
              <span class="lang-pair">
                {{ store.getLanguageName(item.sourceLang) }} → {{ store.getLanguageName(item.targetLang) }}
              </span>
              <el-button
                :icon="Close"
                size="small"
                text
                circle
                @click.stop="store.removeFromHistory(item.id)"
              />
            </div>
            <div class="history-item-text">
              {{ truncateText(item.sourceText, 40) }}
            </div>
            <div class="history-item-time">
              {{ formatTime(item.timestamp) }}
            </div>
          </div>
        </div>
        <div class="sidebar-footer" v-if="store.recentHistory.length > 0">
          <el-button
            :icon="Delete"
            size="small"
            text
            @click="store.clearAllHistory"
          >
            清空历史
          </el-button>
        </div>
      </div>
    </div>
  </div>
</template>

<script setup lang="ts">
import { ref, computed } from 'vue'
import { useTranslatorStore } from '@/stores/translator'
import {
  Promotion,
  Switch,
  Delete,
  Right,
  CopyDocument,
  Reading,
  Loading,
  Warning,
  ChatLineRound,
  Clock,
  ArrowLeft,
  ArrowRight,
  Notebook,
  Close,
  Microphone,
  Picture,
  Document,
} from '@element-plus/icons-vue'
import { ElMessage } from 'element-plus'

const store = useTranslatorStore()
const isHistoryCollapsed = ref(false)
const rating = ref(0)

// 处理翻译动作
const handleTranslate = async () => {
  if (!store.canTranslate) return
  await store.translate()
  // 翻译成功后,可以做一些额外操作,比如滚动到结果区域
}

// 加载历史记录项到当前编辑器
const loadHistoryItem = (item: any) => {
  store.sourceText = item.sourceText
  store.sourceLang = item.sourceLang
  store.targetLang = item.targetLang
  store.translatedText = item.translatedText
  // 可以自动聚焦到输入框
}

// 获取语言完整标签
const getLangLabel = (code: string) => {
  const lang = store.supportedLanguages.find(l => l.code === code)
  return lang ? `${lang.name} (${lang.nativeName})` : code.toUpperCase()
}

// 截断文本用于历史记录显示
const truncateText = (text: string, maxLength: number) => {
  if (text.length <= maxLength) return text
  return text.substring(0, maxLength) + '...'
}

// 格式化时间戳
const formatTime = (timestamp: number) => {
  const date = new Date(timestamp)
  const now = new Date()
  const diff = now.getTime() - timestamp

  // 如果是今天
  if (date.toDateString() === now.toDateString()) {
    return date.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' })
  }
  // 如果是昨天
  if (diff < 48 * 60 * 60 * 1000) {
    return '昨天'
  }
  // 一周内
  if (diff < 7 * 24 * 60 * 60 * 1000) {
    return `${Math.floor(diff / (24 * 60 * 60 * 1000))}天前`
  }
  // 更早
  return date.toLocaleDateString()
}

// 复制到剪贴板
const copyToClipboard = async (text: string) => {
  try {
    await navigator.clipboard.writeText(text)
    ElMessage.success('已复制到剪贴板')
  } catch (err) {
    console.error('复制失败:', err)
    ElMessage.error('复制失败,请手动选择文本复制')
  }
}

// 文本朗读(浏览器TTS API)
const speakText = (text: string) => {
  if (!('speechSynthesis' in window)) {
    ElMessage.warning('您的浏览器不支持文本朗读功能')
    return
  }
  const utterance = new SpeechSynthesisUtterance(text)
  // 根据目标语言设置语音
  utterance.lang = store.targetLang
  speechSynthesis.speak(utterance)
}
</script>

<style scoped>
.translator-container {
  display: flex;
  height: 100vh;
  background: linear-gradient(135deg, #f8fafc 0%, #e2e8f0 100%);
  padding: 20px;
  gap: 20px;
  position: relative;
}

.page-header {
  position: absolute;
  top: 20px;
  left: 20px;
  right: 20px;
  z-index: 10;
}

.page-header h1 {
  margin: 0;
  font-size: 1.8rem;
  color: #1e293b;
  display: flex;
  align-items: center;
  gap: 10px;
}

.subtitle {
  margin: 5px 0 0 0;
  color: #64748b;
  font-size: 0.95rem;
}

.main-translator {
  flex: 1;
  display: flex;
  flex-direction: column;
  gap: 24px;
  margin-top: 80px; /* 给标题留出空间 */
}

.language-controls {
  display: flex;
  justify-content: space-between;
  align-items: center;
  background: white;
  padding: 16px 24px;
  border-radius: 12px;
  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.05);
}

.lang-selector {
  display: flex;
  align-items: center;
  gap: 16px;
}

.swap-btn {
  background: linear-gradient(135deg, #3b82f6 0%, #6366f1 100%);
  color: white;
  border: none;
}

.swap-btn:hover {
  transform: rotate(180deg);
  transition: transform 0.3s ease;
}

.action-buttons {
  display: flex;
  gap: 12px;
}

.translation-editor {
  display: flex;
  gap: 24px;
  flex: 1;
  min-height: 0; /* 重要:让flex子元素可以收缩 */
}

.editor-panel {
  flex: 1;
  display: flex;
  flex-direction: column;
  background: white;
  border-radius: 12px;
  overflow: hidden;
  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.05);
}

.panel-header {
  display: flex;
  justify-content: space-between;
  align-items: center;
  padding: 16px 20px;
  background: #f8fafc;
  border-bottom: 1px solid #e2e8f0;
}

.lang-label {
  font-weight: 600;
  color: #1e293b;
}

.char-count {
  font-size: 0.85rem;
  color: #64748b;
}

.result-actions {
  display: flex;
  gap: 8px;
}

:deep(.el-textarea__inner) {
  flex: 1;
  border: none;
  border-radius: 0;
  padding: 20px;
  font-size: 1rem;
  line-height: 1.6;
  resize: none;
}

:deep(.el-textarea__inner:focus) {
  box-shadow: none;
}

.editor-divider {
  display: flex;
  align-items: center;
  justify-content: center;
  color: #94a3b8;
}

.result-display {
  flex: 1;
  padding: 20px;
  overflow-y: auto;
  font-size: 1rem;
  line-height: 1.6;
  color: #1e293b;
}

.result-display.is-loading {
  display: flex;
  align-items: center;
  justify-content: center;
  color: #64748b;
}

.loading-indicator {
  display: flex;
  flex-direction: column;
  align-items: center;
  gap: 12px;
}

.loading-icon {
  animation: spin 1s linear infinite;
  font-size: 2rem;
  color: #3b82f6;
}

@keyframes spin {
  from { transform: rotate(0deg); }
  to { transform: rotate(360deg); }
}

.error-message {
  display: flex;
  align-items: center;
  gap: 10px;
  color: #ef4444;
  padding: 12px;
  background: #fef2f2;
  border-radius: 8px;
}

.translated-text {
  white-space: pre-wrap;
  word-break: break-word;
}

.placeholder {
  display: flex;
  flex-direction: column;
  align-items: center;
  justify-content: center;
  height: 100%;
  color: #94a3b8;
  gap: 12px;
}

.panel-footer {
  padding: 12px 20px;
  background: #f8fafc;
  border-top: 1px solid #e2e8f0;
  display: flex;
  justify-content: space-between;
  align-items: center;
}

.history-sidebar {
  width: 320px;
  background: white;
  border-radius: 12px;
  overflow: hidden;
  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.05);
  transition: width 0.3s ease;
}

.history-sidebar.is-collapsed {
  width: 60px;
}

.sidebar-header {
  padding: 20px;
  background: linear-gradient(135deg, #3b82f6 0%, #6366f1 100%);
  color: white;
  display: flex;
  align-items: center;
  justify-content: space-between;
  cursor: pointer;
  user-select: none;
}

.sidebar-header span {
  font-weight: 600;
}

.collapse-icon {
  transition: transform 0.3s ease;
}

.sidebar-content {
  height: calc(100% - 64px);
  display: flex;
  flex-direction: column;
}

.empty-history {
  flex: 1;
  display: flex;
  flex-direction: column;
  align-items: center;
  justify-content: center;
  color: #94a3b8;
  gap: 12px;
  padding: 40px 20px;
}

.history-list {
  flex: 1;
  overflow-y: auto;
  padding: 16px;
}

.history-item {
  padding: 16px;
  border-radius: 8px;
  background: #f8fafc;
  margin-bottom: 12px;
  cursor: pointer;
  transition: all 0.2s ease;
  border: 1px solid transparent;
}

.history-item:hover {
  background: #f1f5f9;
  border-color: #e2e8f0;
  transform: translateY(-2px);
}

.history-item-header {
  display: flex;
  justify-content: space-between;
  align-items: center;
  margin-bottom: 8px;
}

.lang-pair {
  font-size: 0.85rem;
  font-weight: 600;
  color: #3b82f6;
}

.history-item-text {
  font-size: 0.95rem;
  color: #1e293b;
  margin-bottom: 8px;
  line-height: 1.4;
}

.history-item-time {
  font-size: 0.75rem;
  color: #64748b;
}

.sidebar-footer {
  padding: 16px;
  border-top: 1px solid #e2e8f0;
  text-align: center;
}
</style>

这个组件看起来代码不少,但其实结构很清晰。它分为几个主要部分:

  1. 语言选择和控制栏:让用户选择源语言和目标语言,可以一键交换。
  2. 文本编辑区域:左边输入原文,右边显示译文。原文区域支持多种输入方式(预留了接口),译文区域提供了复制、朗读等实用功能。
  3. 历史记录侧边栏:可折叠的设计,保存最近的翻译记录,点击可以快速复用。

界面采用了现代化的渐变背景、卡片阴影、平滑动画,整体看起来既专业又不失亲和力。响应式设计也考虑到了,在小屏幕上会自动调整布局。

5. 与后端API集成与优化

前端界面做好了,现在要让它和真正的翻译模型“对话”。Hunyuan-MT-7B部署后,通常会提供一个兼容OpenAI API格式的接口,这让我们前端的集成工作变得简单。

5.1 基础API调用

我们在之前的Store里已经写了一个基础的translate函数。但实际使用中,我们可能需要考虑更多细节。让我们优化一下这个函数,增加流式响应的支持。

流式响应能让用户看到翻译结果逐字逐句地出现,体验更好,尤其对于长文本。我们需要修改 src/stores/translator.ts 中的 translate 函数,或者新增一个流式翻译函数:

// 在translator store中新增流式翻译函数
async function translateStreaming(onChunk: (chunk: string) => void) {
  if (!canTranslate.value) return

  isLoading.value = true
  error.value = null
  translatedText.value = '' // 清空之前的结果

  try {
    // 使用fetch API以便处理流式响应
    const response = await fetch(`${import.meta.env.VITE_API_BASE_URL}/chat/completions`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        // 如果需要认证,在这里添加Authorization头
      },
      body: JSON.stringify({
        model: 'Hunyuan-MT-7B',
        messages: [
          {
            role: 'user',
            content: `请将以下${getLanguageName(sourceLang.value)}文本翻译成${getLanguageName(targetLang.value)}:\n${sourceText.value}`,
          },
        ],
        temperature: 0.3,
        max_tokens: 2048,
        stream: true, // 关键:开启流式响应
      }),
    })

    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`)
    }

    const reader = response.body?.getReader()
    if (!reader) {
      throw new Error('无法读取响应流')
    }

    const decoder = new TextDecoder('utf-8')
    let accumulatedText = ''

    while (true) {
      const { done, value } = await reader.read()
      if (done) break

      const chunk = decoder.decode(value)
      // 解析SSE格式的数据
      const lines = chunk.split('\n')
      
      for (const line of lines) {
        if (line.startsWith('data: ')) {
          const data = line.slice(6)
          if (data === '[DONE]') {
            // 流结束
            addToHistory()
            return
          }
          
          try {
            const parsed = JSON.parse(data)
            const content = parsed.choices?.[0]?.delta?.content || ''
            if (content) {
              accumulatedText += content
              translatedText.value = accumulatedText
              onChunk(content) // 回调,可用于界面动画等
            }
          } catch (e) {
            console.warn('解析流数据失败:', e, '原始数据:', data)
          }
        }
      }
    }
  } catch (err: any) {
    error.value = err.message || '流式翻译过程中发生错误。'
    console.error('流式翻译失败:', err)
  } finally {
    isLoading.value = false
  }
}

然后在组件中,我们可以这样使用流式翻译:

<!-- 在TranslatorView.vue的script部分新增 -->
const handleStreamingTranslate = async () => {
  if (!store.canTranslate) return
  
  // 重置状态
  store.translatedText = ''
  
  await store.translateStreaming((chunk) => {
    // 这里可以添加一些视觉效果,比如打字机动画
    console.log('收到翻译片段:', chunk)
  })
}

5.2 错误处理与重试机制

网络请求总有可能失败。除了我们在axios拦截器里做的通用错误处理,对于翻译这种核心功能,我们还可以添加更友好的重试机制。

// 在store中新增带重试的翻译函数
async function translateWithRetry(maxRetries = 2) {
  let lastError: Error | null = null
  
  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      if (attempt > 0) {
        // 不是第一次尝试,等待一段时间再重试(指数退避)
        const delay = Math.min(1000 * Math.pow(2, attempt - 1), 10000)
        await new Promise(resolve => setTimeout(resolve, delay))
        console.log(`翻译重试第${attempt}次...`)
      }
      
      await translate()
      return // 成功则退出函数
    } catch (err: any) {
      lastError = err
      console.error(`翻译尝试${attempt + 1}失败:`, err)
      
      // 如果是网络错误或超时,可以重试
      // 如果是业务逻辑错误(如参数错误),不应该重试
      const isRetryable = !err.message?.includes('参数') && 
                         !err.message?.includes('认证')
      
      if (!isRetryable || attempt === maxRetries) {
        break
      }
    }
  }
  
  // 所有重试都失败
  if (lastError) {
    throw lastError
  }
}

5.3 请求优化与缓存

为了提升用户体验和减轻服务器压力,我们可以实现一些优化:

  1. 防抖处理:如果用户输入很快,不需要每次按键都触发翻译。可以等用户停止输入一段时间后再自动翻译。
// 在组件中
import { debounce } from 'lodash-es'

// 安装lodash-es:npm install lodash-es @types/lodash-es
const debouncedTranslate = debounce(() => {
  if (store.sourceText.trim().length > 0) {
    handleTranslate()
  }
}, 1000) // 停止输入1秒后触发

// 在输入框上监听输入
watch(() => store.sourceText, () => {
  if (store.sourceText.trim().length > 50) {
    // 只有文本较长时才启用自动翻译
    debouncedTranslate()
  }
})
  1. 本地缓存:对于相同的原文和语言对,我们可以将结果缓存到本地,避免重复请求。
// 简单的内存缓存
const translationCache = new Map<string, string>()

function getCacheKey(sourceText: string, sourceLang: string, targetLang: string) {
  return `${sourceLang}-${targetLang}:${sourceText}`
}

async function translateWithCache() {
  const cacheKey = getCacheKey(store.sourceText, store.sourceLang, store.targetLang)
  
  // 检查缓存
  if (translationCache.has(cacheKey)) {
    store.translatedText = translationCache.get(cacheKey)!
    store.addToHistory()
    return
  }
  
  // 没有缓存,正常翻译
  await translate()
  
  // 保存到缓存
  if (store.translatedText) {
    translationCache.set(cacheKey, store.translatedText)
  }
}

6. 部署实战:前后端分离架构

开发完成后,我们需要把应用部署到线上。这里我们采用前后端分离的架构:前端是静态资源,后端是Hunyuan-MT-7B模型服务。

6.1 前端构建与部署

Vue项目使用Vite构建,生成静态文件非常方便:

npm run build

这会在 dist 目录下生成优化后的静态文件。你可以将这些文件部署到任何静态网站托管服务上,比如:

  • GitHub Pages:免费,适合个人项目演示
  • Vercel / Netlify:对前端项目支持极好,自动CI/CD
  • 阿里云OSS / 腾讯云COS:国内访问速度快,配合CDN更佳

部署时需要注意环境变量的配置。在生产环境中,你需要设置正确的后端API地址。如果你使用Vercel,可以在项目设置中配置环境变量 VITE_API_BASE_URL。

6.2 后端部署与API服务

Hunyuan-MT-7B的部署需要GPU资源。对于个人开发者或小团队,购买和维护物理GPU服务器成本较高。这时,云平台的GPU实例就成了很好的选择。

你可以参考提供的资料中的部署教程,在云服务器上部署Hunyuan-MT-7B。核心步骤通常包括:

  1. 准备GPU环境(CUDA、驱动等)
  2. 下载模型权重
  3. 使用vLLM等推理引擎启动API服务
  4. 配置反向代理(Nginx)和域名

部署完成后,你会得到一个API端点,比如 http://your-server:8021/v1。这就是前端需要连接的后端地址。

6.3 解决跨域问题

前后端分离部署时,经常会遇到跨域问题。解决方法有几种:

  1. 后端配置CORS:在启动API服务时,添加CORS中间件。

    # 如果你使用FastAPI
    from fastapi.middleware.cors import CORSMiddleware
    
    app.add_middleware(
        CORSMiddleware,
        allow_origins=["https://your-frontend-domain.com"],  # 前端域名
        allow_credentials=True,
        allow_methods=["*"],
        allow_headers=["*"],
    )
    
  2. 使用反向代理:通过Nginx将前后端统一到一个域名下。

    server {
        listen 80;
        server_name your-domain.com;
        
        # 前端静态文件
        location / {
            root /path/to/frontend/dist;
            try_files $uri $uri/ /index.html;
        }
        
        # 后端API代理
        location /api/ {
            proxy_pass http://localhost:8021/;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
        }
    }
    

    这样前端只需要请求 /api/ 路径,避免了跨域。

  3. 开发环境代理:在Vite配置中设置代理,方便开发。

    // vite.config.ts
    export default defineConfig({
      server: {
        proxy: {
          '/api': {
            target: 'http://localhost:8021',
            changeOrigin: true,
            rewrite: (path) => path.replace(/^\/api/, ''),
          },
        },
      },
    })
    

7. 总结

走完这一趟,我们从零开始构建了一个完整的翻译应用前端。回顾一下关键点:

我们选择了Vue.js作为前端框架,看中的是它的易用性和强大的响应式系统。通过Pinia,我们把翻译的核心状态和逻辑集中管理,让组件更专注于界面渲染。构建的翻译界面不仅美观实用,还加入了历史记录、流式响应、错误重试、本地缓存等提升用户体验的功能。

与后端Hunyuan-MT-7B的集成,我们采用了兼容OpenAI API的标准方式,这让前端代码有很好的通用性。即使以后换其他翻译模型,只要也提供类似API,我们的前端几乎不用修改。

部署方面,前后端分离的架构让我们能灵活选择部署平台。前端可以托管在性价比高的静态服务上,后端GPU实例则可以按需启停,控制成本。

这个项目只是一个起点。在此基础上,你还可以继续扩展很多功能:用户账户系统、团队协作翻译、文档批量翻译、自定义术语库、翻译质量评估等等。前端技术栈也可以引入更多工具,比如用Vitest做单元测试、用Cypress做E2E测试、用Sentry监控错误。

最重要的是,通过这个实战,你不仅学会了如何用Vue构建AI应用界面,更掌握了一套将先进AI模型转化为实际可用的产品的方法论。这才是最有价值的部分。


获取更多AI镜像

想探索更多AI镜像和应用场景?访问 CSDN星图镜像广场,提供丰富的预置镜像,覆盖大模型推理、图像生成、视频生成、模型微调等多个领域,支持一键部署。