CN117473957A

CN117473957A - Device and method capable of supporting multi-language text analysis

Info

Publication number: CN117473957A
Application number: CN202311408343.7A
Authority: CN
Inventors: 吴桐; 高杨
Original assignee: Zhuhai Gotech Intelligent Technology Co Ltd
Current assignee: Zhuhai Gotech Intelligent Technology Co Ltd
Priority date: 2023-10-26
Filing date: 2023-10-26
Publication date: 2024-01-30

Abstract

The invention provides a device and a method for supporting multi-language text analysis, wherein the method comprises the steps of setting keywords and grammar rules of a text template, positioning the keywords and grammar rules as labels, and defining a binder of keywords and keyword interface classes; designing an analysis interface and an attribute analysis interface of a corresponding structure of each tag, realizing an implementation class default to English according to the analysis interfaces and the attribute analysis interfaces of different tags, and enabling templates to be added with different languages by realizing abstract class abstract language; reading a structured text, converting the read structured text into a char array, converting a structured label of the text into a keyword interface class, and generating an AST grammar tree; analyzing the AST grammar tree and generating an executable unit; and realizing an executable unit runner, and finally calling the executable unit by the client through calling the runner. By applying the method, the switching of different languages can be completed by only setting the language corresponding to the tag before starting text analysis.

Description

Device and method capable of supporting multi-language text analysis

Technical Field

The invention relates to the technical field of computer programs, in particular to a device capable of supporting multi-language text analysis and an analysis method using the device.

Background

At present, the template engine is widely used as an interface and data separation realization, and meanwhile, the development efficiency can be greatly improved. The rule engine can separate complex and repeated business rules from each business system to improve the multiplexing capability and development and change efficiency of business logic and reduce the maintenance and expandability of application programs. The traditional template engine can realize interface and data separation, and the rule engine can reduce maintenance and expandability of the program, but often the two components belong to different third party components, so that a developer needs to learn simultaneously, and a learning curve is increased.

And at the same time, the developer is not the person who is the most aware of the actual business, and needs to communicate with the demand end continuously to increase the development cost. If the user can make the user at the demand end change by a small amount, the program can realize the business purpose without recompilation, and the productivity can be greatly improved. Often, however, the business person will not understand the programming, perhaps logic in the home country, but will not understand English. There is a need for a solution that can meet both template and rules engines, yet allows non-developers to easily go to hand to address and meet these needs.

Thus, the prior art suffers from several drawbacks:

1. for the continuously increased user demands, no template engine and no rule engine need to learn at the same time at present, so that the learning curve and maintenance cost of developers are greatly increased.

2. Because of the business change, the personnel at the demand end needs to communicate with the developer continuously, and finally the developer modifies the code, compiles and reissues.

3. If a part of business logic can be realized by business personnel, the communication is greatly reduced, the time cost for understanding is greatly reduced, and the productivity is greatly improved.

Disclosure of Invention

The device and the method can provide a set of simulated JAVA grammar, expand special labels based on text analysis and rule engines, and enable a user to complete switching of different languages by setting the corresponding languages of the labels before starting text analysis.

The invention realizes the above purpose through the following technical scheme:

a device capable of supporting multi-language text analysis comprises a reading module, a processing module and a processing module, wherein the reading module is used for reading configuration information before system starting;

the conversion module is used for converting the read structured text into a char array;

the structure interface analysis module analyzes the structure text and analyzes the structure label in the text to generate an AST grammar tree;

the attribute interface analysis module analyzes the structured text and adds the attribute in the text to the corresponding grammar tree node;

and the grammar tree operation module is used for operating the generated grammar tree.

A method capable of supporting multi-language text parsing is applied to a device capable of supporting multi-language text parsing for multi-language text parsing, and comprises the following steps:

setting keywords and grammar rules of a text template, positioning the keywords and grammar rules as labels, and defining a binder of keywords and keyword interface classes; the binding device is used for binding the relation between the keywords and the keyword interface class, and decoupling the keywords through the binding device;

designing an analysis interface and an attribute analysis interface of a corresponding structure of each tag, realizing an implementation class default to English according to the analysis interfaces and the attribute analysis interfaces of different tags, and enabling templates to be added with different languages by realizing abstract class abstract language;

reading a structured text, converting the read structured text into a char array, converting a structured label of the text into a keyword interface class, and generating an AST grammar tree;

analyzing the AST grammar tree and generating an executable unit;

and realizing an executable unit runner, and finally calling the executable unit by the client through calling the runner.

According to the present invention, a method for supporting multi-language text parsing is provided, wherein the binder for defining keywords and keyword interface classes includes:

all keyword interfaces are inherited to the parent BluerintTag, each interface corresponds to one keyword and is English by default, and the language of the keywords is decoupled and changed through a binder;

if a keyword which needs to define a specific language is used, a specific binder needs to be created, and the creation of the specific binder is realized by inheriting an abstract class abstract language tagfactor.

According to the method for supporting multi-language text parsing provided by the invention, the keyword is decoupled through the binder, and the method comprises the following steps:

the key and key interface are bound through abstract class abstract language tagfactor.

According to the method for supporting multi-language text parsing provided by the invention, the analysis interface and the attribute parsing interface of each label corresponding structure are designed, and the method comprises the following steps:

in the whole program design, if the keywords are in the form of packages, the keywords are: the xxxx' starts and ends with "# xxx", and the key fonts can contain other key words, which are called as structured interfaces, namely the key words are structured classes, and the structured interfaces comprise structured interfaces and attribute interfaces; if exec ends without #, exec is an attribute interface, and the attribute interface cannot contain both the attribute interface and the structured interface.

According to the method capable of supporting multi-language text analysis, when the structured label of the text is converted into a keyword interface class, the character string is converted into an array, and the character string array is analyzed through an analysis function in a Standard ScannerDispatch;

after the parsing function reads an array, the parsing function starts from array index 0 until the array ends to analyze character by character until a unique implementation class of the structural interface or attribute parsing interface is selected.

According to the method for supporting multi-language text analysis, when the implementation class of the best matching structure interface or the attribute analysis interface is selected, the implementation class is mounted in an AnalysisSupport class;

then the self continues to call the analyzing function to find the implementation class of the next best matching structural interface or attribute parsing interface.

According to the method capable of supporting multi-language text parsing, after the AST grammar tree is built, an analysis function in AttributeManger is called to package the AST, and then a rule function of CompileManger is called to convert the AST grammar tree into an executable unit MetaAssemble.

According to the method capable of supporting multi-language text analysis, after the program generates the executable unit, the executable unit is recursively loaded through the instrumentation manager, and a list of PackageContext is returned according to the maximum structure package;

and then loading the PackageContext list into the VirtualRun class, and finally, by instantiating the class, inputting corresponding parameters to execute corresponding results.

Compared with the prior art, the scheme and the architecture which can support multi-language text parsing are realized under Java language, a set of simulated JAVA grammar is provided, special labels based on text parsing and a rule engine are expanded, and a user can complete switching of different languages by setting the corresponding languages of the labels just before starting text parsing. Therefore, the invention reduces the learning curve of the developer through the unified template engine and the rule engine, and can simply realize multiple languages through the configurator.

The invention is described in further detail below with reference to the drawings and the detailed description.

Drawings

FIG. 1 is a first flowchart of a method for supporting multi-language text parsing in accordance with an embodiment of the present invention.

FIG. 2 is a second flowchart of an embodiment of a method for supporting multi-language text parsing in accordance with the present invention.

FIG. 3 is a program code schematic diagram of a binder using English in an embodiment of a method for supporting multi-language text parsing according to the present invention.

FIG. 4 is a diagram of program code related to a Retuntag. Class interface in an embodiment of a method for supporting multi-language text parsing according to the present invention.

FIG. 5 is a program code schematic diagram of a structure interface and an attribute parsing interface in an embodiment of a method for supporting multi-language text parsing according to the present invention.

FIG. 6 is a diagram of first program code related to an parsing function in a method for supporting multi-language text parsing according to an embodiment of the present invention.

FIG. 7 is a diagram of second program code related to an parsing function in an embodiment of a method for supporting multi-language text parsing according to the present invention.

FIG. 8 is a diagram of third program code related to an parsing function in an embodiment of a method for supporting multi-language text parsing according to the present invention.

FIG. 9 is a program code diagram of a PackageContext list in an embodiment of a method for supporting multi-language text parsing according to the present invention.

FIG. 10 is a diagram of first program code related to execution results in a method for supporting multi-language text parsing according to an embodiment of the present invention.

FIG. 11 is a diagram illustrating a second program code related to execution results in a method for supporting multi-language text parsing according to an embodiment of the present invention.

Detailed Description

In order to make the objects, technical solutions and advantages of the embodiments of the present invention more clear, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings of the embodiments of the present invention. It will be apparent that the described embodiments are some, but not all, embodiments of the invention. All other embodiments, which can be made by a person skilled in the art without creative efforts, based on the described embodiments of the present invention fall within the protection scope of the present invention.

Reference herein to "an embodiment" means that a particular feature, structure, or characteristic described in connection with the embodiment may be included in at least one embodiment of the present application. The appearances of such phrases in various places in the specification are not necessarily all referring to the same embodiment, nor are separate or alternative embodiments mutually exclusive of other embodiments. Those of skill in the art will explicitly and implicitly appreciate that the embodiments described herein may be combined with other embodiments.

First, some of the terms and related techniques referred to in the present application are explained for easy understanding by those skilled in the art.

An interface (interface) is an abstract type in the Java language, which is a collection of abstract methods, and the interface is usually declared by interface. One class inherits and implements abstract methods in an interface by inheriting the way the interface is inherited.

Annotation (Annoation), also called metadata, a description of the code level. It is a feature introduced by JDK1.5 and later versions, at the same level as class, interface, enumeration. It may be declared in front of packages, classes, fields, methods, local variables, method parameters, etc. to illustrate these elements.

The template engine (here, a template engine for Web development is specifically referred to as a template engine) is generated to separate the user interface from the business data (content), and can generate a document in a specific format, and the template engine for the website generates a standard HTML document.

The rule engine is developed by an inference engine and is a component embedded in an application program, which implements the separation of business decisions from application code and the writing of business decisions using predefined semantic modules. And receiving data input, interpreting the business rule, and making a business decision according to the business rule.

Device embodiment capable of supporting multi-language text parsing

Referring to fig. 1 and 2, an apparatus for supporting multi-language text parsing according to the present invention includes: the reading module is used for reading the configuration information before the system is started;

An embodiment of a method for supporting multi-language text parsing:

the present invention relates to a method for supporting multiple language text parsing, and more particularly to a method for supporting multiple language text parsing by using a Java language. The method for supporting multi-language text parsing provided in the embodiment is applied to the device for supporting multi-language text parsing to perform multi-language text parsing, and includes the following steps:

step S1, setting keywords and grammar rules of a text template, positioning the keywords and grammar rules as labels, and defining a binder of keywords and keyword interface classes; the binding device is used for binding the relation between the keywords and the interface classes of the keywords, and decoupling the keywords (English, chinese and the like correspond to the same interface class) through the binding device;

step S2, designing an analysis interface and an attribute analysis interface (for example, if (i= 0) of a corresponding structure of each label (for example, if else and the like), wherein "(i= 0) is an attribute, realizing an implementation class defaulting to English according to the analysis interfaces and the attribute analysis interfaces of different labels, and enabling templates to be added with different languages by realizing abstract class abstract language;

step S3, a tag reader is realized, a structured text is read, the read structured text is converted into a char array, the structured tag of the text is converted into a keyword interface class, after the reading by the reader is finished, char [ ] characters are delivered to a structure interface and an attribute interface, so that the char array is generated into an AST grammar tree, and the AST grammar tree is generated;

and S4, analyzing the AST grammar tree and generating an executable unit through the realization of the label analysis interface. The key point of step S4 is that the keywords are based on interfaces rather than the text of the keywords, so long as the binder is configured, the meanings of different keywords in terms of the faces are converted into unified expressions of the interface classes of the keywords, the whole program encounters the interface classes of the keywords, the text of the keywords is regarded as the meanings of the interface classes of the keywords in terms of the program), and an executable unit for text analysis is generated.

And S5, realizing an executable unit runner, and finally calling the executable unit by the client through calling the runner.

In this embodiment, a binder defining a key and a key interface class includes:

In this embodiment, the keywords are fixed (interfaces in JAVA code) when the program is written, all the keywords are inherited by interfaces in parent blurringttag), each of the interfaces corresponds to one keyword and is english by default, and the user cannot add the keywords at will because the keywords still need to be implemented after definition, and hard coding is needed here.

If a keyword requiring definition of a specific language is used, a specific binder needs to be created, and the creation of the specific binder is realized by inheriting an abstract class abstract language tagfactor.

In this embodiment, decoupling keywords by the binder includes:

the system binds the key words and key word interfaces through abstract class abstract language tagfactor.

As shown in fig. 3, for example: the key word corresponding to the retruntag. Class interface is return, and the program defaults to using an English binding device. A Chinese binder for the CNLanguageTagFactoy is also provided. If more languages need to be implemented, then it is necessary to inherit the abstract language tagfactor by itself and rewrite static bindings.

As shown in fig. 4, the key corresponding to the retruntag.

In this embodiment, designing an analysis interface and an attribute analysis interface of each label corresponding structure includes:

Specifically, in the whole programming, if the keyword appears in a package form, the keyword is: xxxx "starts with" #xxx "and the key font can contain other implementations of keywords, which in this embodiment is referred to as a structured interface, then the keyword class is a structured class, and the structured class is represented in the template. For example, the [ template: funcDemo (list) ] key in fig. 5, heel funcDemo (list), end [ # funcDemo ] tie with # number, then the template interface is the structured interface; for example, [ if @ list = null ] [ else ] [ if ] the tie-in # symbol if else is a structured interface; for example, [ exec: 'leech' ] exec ends without #, exec is an attribute interface because exec cannot contain other attribute interfaces or structured interfaces inside. It can be seen that the structured interface is embodied in the template in that the structured interface can include a structured interface and an attribute interface, and the attribute interface cannot include an attribute interface and a structured interface.

In this embodiment, as shown in fig. 6 to 8, the read structured text is actually a character string, when the structured label of the text is converted into a keyword interface class, the character string is first converted into an array, and the character string array is analyzed by an analyzing function in a standard scannerdisplacement;

after the parsing function reads an array, the parsing function starts with array index 0 until the array ends, for example: and if a plurality of characters with the subscript of 0 are read, the next subscript of the array is continuously read until a unique structural interface or an implementation class of the attribute analysis interface is selected.

When the implementation class of the interface with the best matching structure or the attribute analysis interface is selected, the implementation class is mounted into an AnalyssSupport class;

In this embodiment, the AnalysisSupport is an AST management class, which maintains an AST tree (nodeUnit) itself. When the char array is read, the AST is constructed. After the AST tree is built, the program can call an analysis function in the AttributeManger to package the AST, and then call a combile function of the CompileManger to finally convert the AST into an executable unit MetaAssemble.

After the program generates the executable unit, the executable unit is recursively loaded through the instrumnager, and a list of the PackageContext is returned according to the maximum structure package, as shown in fig. 9.

And then loading the PackageContext list into the VirtualRun class, and finally, by instantiating the class and inputting corresponding parameters, executing corresponding results, as shown in FIG. 10 and FIG. 11.

Compared with the prior art, the embodiment provides a scheme and architecture capable of supporting multi-language text parsing, the scheme and architecture are realized under Java language, a set of simulated JAVA grammar is provided, special labels based on text parsing and rule engines are expanded, and a user can complete switching of different languages by setting the corresponding languages of the labels just before starting text parsing. Therefore, the embodiment reduces the learning curve of the developer through the unified template engine and the rule engine, and can simply realize multiple languages through the configurator.

The above embodiments are only preferred embodiments of the present invention, and the scope of the present invention is not limited thereto, but any insubstantial changes and substitutions made by those skilled in the art on the basis of the present invention are intended to be within the scope of the present invention as claimed.

Claims

1. An apparatus for supporting multi-language text parsing, comprising:

the reading module is used for reading the configuration information before the system is started;

2. A method for supporting multi-language text parsing, wherein the method is applied to an apparatus for supporting multi-language text parsing as claimed in claim 1, and comprises:

analyzing the AST grammar tree and generating an executable unit;

3. The method of claim 2, wherein the binder defining keywords and keyword interface classes comprises:

4. The method of claim 2, wherein the decoupling keywords by the binder comprises:

5. The method according to claim 2, wherein designing the analysis interface and the attribute parsing interface of each tag corresponding structure includes:

6. The method according to claim 2, characterized in that:

when converting the structured label of the text into a keyword interface class, converting the character string into an array, and analyzing the character string array through an analyzing function in a standard ScannerDispatch;

7. The method according to claim 6, wherein:

8. The method according to claim 2, characterized in that:

after the AST grammar tree is built, an analysis function in the AttributeManger is called to package the AST, and then a combile function of the CompileManger is called to convert the AST grammar tree into an executable unit MetaAssemble.

9. The method according to claim 2, characterized in that:

after the program generates the executable unit, recursively loading the executable unit through an instrumagemanager, and returning a list of the PackageContext according to the maximum structure package;