Interface internationalization language switching method based on go language
By defining translation data processing functions and automatically triggering translation processing in Go, and combining database and file storage for multilingual data, the problems of coupling translation data with business logic and inadequate caching in interface internationalization are solved, achieving efficient multilingual switching and flexible translation management.
Patent Information
- Application Number
- CN202511666852.9
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2025-11-14
- Publication Date
- 2026-03-03
AI Technical Summary
Existing Go language interface internationalization solutions suffer from problems such as coupling translation data with business logic, lack of efficient fuzzy matching mechanisms, and imperfect caching mechanisms, resulting in high maintenance costs, difficulty in dynamic switching, and performance bottlenecks.
It adopts an interface internationalization method based on the Go language. By defining translation data processing functions, the fields to be translated in the interface response message are converted into JSON objects, key values are recursively matched, and translation processing is automatically triggered after the interface business logic is executed. It combines database and file storage for multilingual translation data, supports precise and fuzzy matching, and uses a caching mechanism to optimize data management.
It enables dynamic translation of interface response messages, supports efficient dual-mode matching, reduces storage overhead and response latency, improves the flexibility and efficiency of multilingual switching, and achieves separation of business logic and translation logic.
Smart Images
Figure CN121598967A_ABST
Abstract
Description
Technical Field
[0001] This invention discloses a method for switching the internationalized language of an interface based on the Go language, which relates to the field of interface data processing technology. Background Technology
[0002] In the context of globalization, interface internationalization has become a core requirement of modern software development. Existing solutions typically employ hard-coded multilingual text or simple replacement methods, which suffer from high maintenance costs and difficulties in dynamic switching.
[0003] In existing technologies, Go primarily achieves static text translation through formatted output in the standard library or third-party libraries such as go-i18n, but lacks a systematic solution for dynamically processing interface response messages. Current mainstream solutions have several drawbacks, such as: first, strong coupling between translation data and business logic leads to bloated code; second, a lack of efficient fuzzy matching mechanisms makes it unable to handle complex text with dynamic parameters; and third, inadequate caching mechanisms lead to performance bottlenecks due to frequent database or file accesses. Summary of the Invention
[0004] This invention addresses the problems of existing technologies by providing a method for switching internationalized interfaces based on the Go language. This method is characterized by its strong versatility and ease of implementation, and has broad application prospects.
[0005] The specific solution proposed in this invention is as follows:
[0006] This invention provides a method for switching the internationalized language of an interface based on the Go language, comprising:
[0007] Step 1: Define a translation data processing function to convert the fields to be translated in the interface response message into JSON objects, and recursively match the key values of the JSON objects with the key values of the pre-stored translation text;
[0008] Step 2: Bind the translation data processing function to the target interface, so that translation processing is automatically triggered after the interface business logic is executed;
[0009] Step 3: Pre-store multilingual translation data through a database table or JSON file. The storage structure includes a source language column and multiple target language columns, with source language data and target language data in the same row corresponding one-to-one.
[0010] Step 4: During response message processing, dynamically load the translation data for the corresponding target language based on the language parameter in the request header, and complete the text replacement through exact matching or fuzzy matching.
[0011] Furthermore, in step 1 of the Go-based interface internationalization language switching method, the fields to be translated in the interface response message of the backend interface are converted into JSON objects. The JSON objects are recursively traversed, and the key values in the JSON objects are matched with the key values of the pre-stored translation text. If a match is successful, the value data in the pre-stored translation text is used to replace the JSON objects, and the JSON objects are updated in the interface response message, and the interface response message is output.
[0012] Furthermore, in step 1 of the Go-based interface internationalization language switching method, a translation data processing function is defined, including:
[0013] The default fuzzy matching rule for the translation data processing function is to split the string to be matched into default language and non-default language parts, and replace the non-default language parts with placeholders.
[0014] The placeholder string is matched precisely with the translated text; if a match is found, a replacement is performed.
[0015] Furthermore, in step 3 of the Go-based interface internationalization language switching method, multilingual translation data is pre-stored. A table is stored in the database to store one source language and multiple target languages. The table has multiple columns, each storing data for one language. The first column of the table contains the data to be translated, and the other columns contain the target language data.
[0016] Furthermore, step 3 of the Go-based interface internationalization language switching method uses a translation data caching mechanism, including: loading translation data from a database or file and converting it into a Map structure, with each Map corresponding to a target language; setting a caching period of 30 minutes by default, after which the cache is automatically cleaned up and reloaded.
[0017] This invention also provides a Go-based interface internationalization language switching device, including a function management module, a binding module, a pre-storage module, and a response message processing module.
[0018] The function management module defines translation data processing functions that convert the fields to be translated in the interface response message into JSON objects and recursively match the key values of the JSON objects with the key values of the pre-stored translation text.
[0019] The binding module binds the translation data processing function to the target interface, automatically triggering translation processing after the interface's business logic is executed;
[0020] The pre-storage module pre-stores multilingual translation data through database tables or JSON files. The storage structure includes source language columns and multiple target language columns, with source language data and target language data in the same row corresponding one-to-one.
[0021] When processing response messages, the response message processing module dynamically loads the translation data for the corresponding target language based on the language parameters in the request header, and completes the text replacement through exact matching or fuzzy matching.
[0022] Furthermore, the function management module of the interface internationalization language switching device based on Go language converts the fields to be translated in the interface response message of the backend interface into JSON objects, recursively traverses the JSON objects, matches the key values in the JSON objects with the key values of the pre-stored translation text, and if a match is successful, replaces the value data with the pre-stored translation text, updates the JSON object in the interface response message, and outputs the interface response message.
[0023] Furthermore, the function management module of the Go-based interface internationalization language switching device defines translation data processing functions, including:
[0024] The default fuzzy matching rule for the translation data processing function is to split the string to be matched into default language and non-default language parts, and replace the non-default language parts with placeholders.
[0025] The placeholder string is matched precisely with the translated text; if a match is found, a replacement is performed.
[0026] Furthermore, the pre-storage module of the interface internationalization language switching device based on the Go language stores multilingual translation data in a database table for storing one source language and multiple target languages. The table has multiple columns, each storing data for one language. The first column of the table contains the data to be translated, and the other columns contain the target language data.
[0027] Furthermore, the pre-storage module of the Go-based interface internationalization language switching device uses a translation data caching mechanism, including: loading translation data from a database or file and converting it into a Map structure, with each Map corresponding to a target language; setting a caching period of 30 minutes by default, and automatically cleaning up and reloading after the timeout.
[0028] The advantages of this invention are:
[0029] Dynamic translation of response messages is implemented: By decoupling the translation processor from the interface, the text replacement process can be automatically triggered after the interface execution is complete. A recursive traversal of the JSON object is used to accurately locate and replace multilingual fields in the response message, achieving separation of business logic and translation logic.
[0030] An efficient dual-mode matching mechanism can be constructed, which can employ both exact matching and fuzzy matching to support accurate translation of composite texts containing dynamic parameters.
[0031] Optimize translation data management architecture: Supports a hybrid database and file storage mode, allowing users to choose between single or hybrid storage solutions as needed. Significantly reduces storage overhead and response latency through automatic caching mechanisms and language-categorized Map object management.
[0032] Enhance the flexibility of multilingual switching: Support dynamic switching of multiple arbitrary language pairs, only the translation files of the corresponding language pairs need to be maintained, and the original language text can reuse the same key value, avoiding duplicate storage. Attached Figure Description
[0033] Figure 1 This is a schematic diagram of the method flow of the present invention.
[0034] Figure 2 This is a flowchart of the translation data processing function.
[0035] Figure 3 This is a flowchart of the translation data loading process.
[0036] Figure 4 This is a flowchart of the fuzzy matching process for translation data.
[0037] Figure 5 This is a diagram illustrating the storage format of translation data files. Detailed Implementation
[0038] The present invention will be further described below with reference to the accompanying drawings and specific embodiments, so that those skilled in the art can better understand and implement the present invention. However, the embodiments described are not intended to limit the present invention.
[0039] Example 1
[0040] This invention provides a method for switching the internationalized language of an interface based on the Go language, comprising:
[0041] Step 1: Define a translation data processing function to convert the fields to be translated in the interface response message into JSON objects, and recursively match the key values of the JSON objects with the key values of the pre-stored translation text.
[0042] The process involves converting the fields to be translated in the backend interface response message into JSON objects, recursively traversing the JSON objects, matching the key values in the JSON objects with the key values in the pre-stored translation text, replacing the key values with the value data from the pre-stored translation text, updating the JSON objects in the interface response message, and then outputting the interface response message.
[0043] Furthermore, when defining translation data processing functions, the following can be included:
[0044] The default fuzzy matching rule for the translation data processing function is to split the string to be matched into default language and non-default language parts, and replace the non-default language parts with placeholders.
[0045] The placeholder string is matched precisely with the translated text; if a match is found, a replacement is performed.
[0046] Figure 2 The execution flow of the Chinese translation data processing function is as follows: The function takes request and response information as input parameters. First, it retrieves the language parameters from the request and loads the corresponding translation data from the cache based on these parameters. Then, it retrieves the body data from the response and converts it into a JSON object. It iterates through the keys in the JSON object, performing an exact match between each key and the keys in the translation data map. If an exact match fails, a fuzzy match is performed. For successful exact or fuzzy matches, the value corresponding to the key in the JSON object is updated. After the iteration is complete, the JSON object is updated in the response, and the response is output.
[0047] Step 2: Bind the translation data processing function to the target interface, so that translation processing is automatically triggered after the interface business logic is executed;
[0048] Step 3: Pre-store multilingual translation data using a database table or JSON file. The storage structure includes source language columns and multiple target language columns. Source language data and target language data in the same row correspond one-to-one. For pre-stored multilingual translation data, a table is stored in the database to store one source language and multiple target languages. This table has multiple columns, each storing data for one language. The first column of the table contains the data to be translated, and the other columns contain the target language data. For example, the first column header might be "zh" for Chinese, the second "en" for English, and the third "ja" for Japanese. If the first column of the same row stores "memory", the second "memory", and the third "memory", then if the original message contains "memory", switching the language to English will replace "memory" with "memory", and switching the language to logs will replace "memory" with "memory".
[0049] Figure 5The data file storage format for the Chinese translation is as follows: Files are stored in JSON format, where the key is the source text and the value is the target text. Each type of target text is stored in a separate file. In the diagram, the source text is Chinese, and the target text is English. If you only need to switch between Chinese and English, then the single file `zh-en.json` is sufficient to store the translated text. If you want to switch between Chinese, English, and Japanese, you need to define a separate file `zh-ja.json`, where the key remains the same (still Chinese), and the value must be Japanese.
[0050] Step 3 also uses a translation data caching mechanism, including: loading translation data from a database or file and converting it into a Map structure, with each Map corresponding to a target language; setting the caching period, which is 30 minutes by default, and automatically cleaning up and reloading after the timeout.
[0051] Figure 3 The Chinese translation data loading and execution process is as follows: Text translation data is loaded from a database or file and converted into map objects. The key is the source text, and the value is the target text. The map data is then cached for a default period of 30 minutes, after which it is cleared. A single map object can only store one type of target text. If switching between multiple languages is required, multiple map objects need to be generated. Each map object will have the same key (Chinese data), but different values (the target language data for each object).
[0052] Step 4: During response message processing, dynamically load the translation data for the corresponding target language based on the language parameter in the request header, and complete the text replacement through exact matching or fuzzy matching.
[0053] Figure 4 The fuzzy matching process for Chinese translation data is as follows: Fuzzy matching divides the key string into two parts: the default language and a non-default language. For example, if the default language is Chinese, then during fuzzy matching, the string is divided into Chinese and non-Chinese parts. The Chinese part remains unchanged, while the non-Chinese part is replaced with placeholders. For example, the text "Host:test-001's CPU usage is higher than 20%" becomes "Host {1}'s {2} usage is higher than {3}" after placeholder replacement. Then, it is matched precisely with the key value in the translation data. If a match is found, the fuzzy matching is considered successful; otherwise, the matching fails.
[0054] Example 2
[0055] This invention also provides a Go-based interface internationalization language switching device, including a function management module, a binding module, a pre-storage module, and a response message processing module.
[0056] The function management module defines translation data processing functions that convert the fields to be translated in the interface response message into JSON objects and recursively match the key values of the JSON objects with the key values of the pre-stored translation text.
[0057] The binding module binds the translation data processing function to the target interface, automatically triggering translation processing after the interface's business logic is executed;
[0058] The pre-storage module pre-stores multilingual translation data through database tables or JSON files. The storage structure includes source language columns and multiple target language columns, with source language data and target language data in the same row corresponding one-to-one.
[0059] When processing response messages, the response message processing module dynamically loads the translation data for the corresponding target language based on the language parameters in the request header, and completes the text replacement through exact matching or fuzzy matching.
[0060] The information interaction and execution process between the modules in the above-mentioned device are based on the same concept as the method embodiment of the present invention, and the specific details can be found in the description in the method embodiment of the present invention, and will not be repeated here.
[0061] Similarly, the advantages of the device of the present invention are:
[0062] Dynamic translation of response messages is implemented: By decoupling the translation processor from the interface, the text replacement process can be automatically triggered after the interface execution is complete. A recursive traversal of the JSON object is used to accurately locate and replace multilingual fields in the response message, achieving separation of business logic and translation logic.
[0063] An efficient dual-mode matching mechanism can be constructed, which can employ both exact matching and fuzzy matching to support accurate translation of composite texts containing dynamic parameters.
[0064] Optimize translation data management architecture: Supports a hybrid database and file storage mode, allowing users to choose between single or hybrid storage solutions as needed. Significantly reduces storage overhead and response latency through automatic caching mechanisms and language-categorized Map object management.
[0065] Enhance the flexibility of multilingual switching: Support dynamic switching of multiple arbitrary language pairs, only the translation files of the corresponding language pairs need to be maintained, and the original language text can reuse the same key value, avoiding duplicate storage.
[0066] It should be noted that not all steps and modules in the above processes and device structures are mandatory; some steps or modules may be omitted as needed. The execution order of each step is not fixed and can be adjusted as required. The device structures described in the above embodiments can be physical structures or logical structures. That is, some modules may be implemented by the same physical entity, or some modules may be implemented by multiple physical entities, or they may be jointly implemented by certain components in multiple independent devices.
[0067] The above-described embodiments are merely preferred embodiments provided to fully illustrate the present invention, and the scope of protection of the present invention is not limited thereto. Equivalent substitutions or modifications made by those skilled in the art based on the present invention are all within the scope of protection of the present invention. The scope of protection of the present invention is defined by the claims.
Claims
1. A method for internationalizing the language of an interface based on the Go language, characterized by: include: Step 1: Define a translation data processing function to convert the fields to be translated in the interface response message into JSON objects, and recursively match the key values of the JSON objects with the key values of the pre-stored translation text; Step 2: Bind the translation data processing function to the target interface, so that translation processing is automatically triggered after the interface business logic is executed; Step 3: Pre-store multilingual translation data through a database table or JSON file. The storage structure includes a source language column and multiple target language columns, with source language data and target language data in the same row corresponding one-to-one. Step 4: During response message processing, dynamically load the translation data for the corresponding target language based on the language parameter in the request header, and complete the text replacement through exact matching or fuzzy matching.
2. The method for switching the internationalized interface language based on Go language according to claim 1, characterized in that: In step 1, the fields to be translated in the backend interface response message are converted into JSON objects. The JSON objects are recursively traversed, and the key values in the JSON objects are matched with the key values of the pre-stored translation text. If a match is found, the value data in the pre-stored translation text is used to replace the JSON objects, the JSON objects are updated in the interface response message, and the interface response message is output.
3. A method for switching the internationalized interface language based on Go language according to claim 1 or 2, characterized in that: Step 1 defines the translation data processing functions, including: The default fuzzy matching rule for the translation data processing function is to split the string to be matched into default language and non-default language parts, and replace the non-default language parts with placeholders. The placeholder string is matched precisely with the translated text; if a match is found, a replacement is performed.
4. The method for internationalizing interface language switching based on Go language according to claim 1, characterized in that in step 3, the pre-stored multilingual translation data is stored in a database in a table to store one source language and multiple target languages, the table has multiple columns, each column stores one language data, the first column of the table is the data to be translated, and the other columns are the target language data.
5. A method for switching the internationalized interface language based on Go language according to claim 1, characterized in that: Step 3 uses a translation data caching mechanism, which includes: loading translation data from a database or file and converting it into a Map structure, with each Map corresponding to a target language; setting the caching period, which is 30 minutes by default, and automatically cleaning up and reloading after the timeout.
6. A language switching device for internationalization of interfaces based on the Go language, characterized in that: It includes a function management module, a binding module, a pre-storage module, and a response message processing module. The function management module defines translation data processing functions that convert the fields to be translated in the interface response message into JSON objects and recursively match the key values of the JSON objects with the key values of the pre-stored translation text. The binding module binds the translation data processing function to the target interface, automatically triggering translation processing after the interface's business logic is executed; The pre-storage module pre-stores multilingual translation data through database tables or JSON files. The storage structure includes source language columns and multiple target language columns, with source language data and target language data in the same row corresponding one-to-one. When processing response messages, the response message processing module dynamically loads the translation data for the corresponding target language based on the language parameters in the request header, and completes the text replacement through exact matching or fuzzy matching.
7. A language switching device for interface internationalization based on Go language according to claim 6, characterized in that: The function management module converts the fields to be translated in the interface response message of the backend interface into JSON objects, recursively traverses the JSON objects, matches the key values in the JSON objects with the key values of the pre-stored translation text, and if a match is found, replaces the value data with the pre-stored translation text, updates the JSON object in the interface response message, and outputs the interface response message.
8. A language switching device for interface internationalization based on Go language according to claim 6 or 7, characterized in that: The function management module defines translation data processing functions, including: The default fuzzy matching rule for the translation data processing function is to split the string to be matched into default language and non-default language parts, and replace the non-default language parts with placeholders. The placeholder string is matched precisely with the translated text; if a match is found, a replacement is performed.
9. A language switching device for interface internationalization based on Go language according to claim 6, characterized in that: The pre-storage module stores multilingual translation data in a database table to store one source language and multiple target languages. The table has multiple columns, each storing data for one language. The first column of the table contains the data being translated, and the other columns contain the target language data.
10. A language switching device for interface internationalization based on Go language according to claim 6, characterized in that: The pre-storage module uses a translation data caching mechanism, which includes: loading translation data from a database or file and converting it into a Map structure, with each Map corresponding to a target language; setting the caching period, which is 30 minutes by default, and automatically cleaning up and reloading after the timeout.