CN113268425B - Rule-based micro-service source file preprocessing method - Google Patents
Rule-based micro-service source file preprocessing method Download PDFInfo
- Publication number
- CN113268425B CN113268425B CN202110587637.5A CN202110587637A CN113268425B CN 113268425 B CN113268425 B CN 113268425B CN 202110587637 A CN202110587637 A CN 202110587637A CN 113268425 B CN113268425 B CN 113268425B
- Authority
- CN
- China
- Prior art keywords
- rules
- service
- micro
- rule
- file
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
- 238000000034 method Methods 0.000 title claims abstract description 98
- 238000007781 pre-processing Methods 0.000 title claims abstract description 39
- 230000008569 process Effects 0.000 claims abstract description 62
- 238000001514 detection method Methods 0.000 claims abstract description 17
- 238000011156 evaluation Methods 0.000 claims abstract description 17
- 230000006870 function Effects 0.000 claims description 31
- 238000013507 mapping Methods 0.000 claims description 24
- 239000003550 marker Substances 0.000 claims description 21
- 238000012545 processing Methods 0.000 claims description 15
- 238000012854 evaluation process Methods 0.000 claims description 11
- 238000001914 filtration Methods 0.000 claims description 10
- 238000000638 solvent extraction Methods 0.000 claims description 7
- 230000003068 static effect Effects 0.000 abstract description 16
- 238000012360 testing method Methods 0.000 description 8
- 230000008520 organization Effects 0.000 description 7
- 230000009286 beneficial effect Effects 0.000 description 3
- 238000011161 development Methods 0.000 description 3
- 239000000284 extract Substances 0.000 description 3
- 238000010276 construction Methods 0.000 description 2
- 238000010586 diagram Methods 0.000 description 2
- 238000005516 engineering process Methods 0.000 description 2
- 230000008859 change Effects 0.000 description 1
- 230000008878 coupling Effects 0.000 description 1
- 238000010168 coupling process Methods 0.000 description 1
- 238000005859 coupling reaction Methods 0.000 description 1
- 230000001419 dependent effect Effects 0.000 description 1
- 238000013461 design Methods 0.000 description 1
- 230000002708 enhancing effect Effects 0.000 description 1
- 230000007717 exclusion Effects 0.000 description 1
- 238000000605 extraction Methods 0.000 description 1
- 230000002349 favourable effect Effects 0.000 description 1
- 230000003993 interaction Effects 0.000 description 1
- 238000012804 iterative process Methods 0.000 description 1
- 238000005192 partition Methods 0.000 description 1
- 238000013441 quality evaluation Methods 0.000 description 1
- 230000004044 response Effects 0.000 description 1
- 238000006467 substitution reaction Methods 0.000 description 1
- 230000001131 transforming effect Effects 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
- G06F8/75—Structural analysis for program understanding
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3604—Software analysis for verifying properties of programs
- G06F11/3608—Software analysis for verifying properties of programs using formal methods, e.g. model checking, abstract interpretation
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
- Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management
Abstract
The invention discloses a micro-service source file preprocessing method based on rules, which is characterized in that according to code characteristics and coding specifications of a micro-service source file, a complex and variable part of the micro-service source file is extracted to form rules, the preprocessing process of the micro-service source file is realized and controlled in a configurable mode, and micro-service item source files which are various in form and difficult to process are converted into a form which is uniform in format and easy to process, so that key information used for evaluation can be extracted as much as possible during single static detection traversal.
Description
Technical Field
The invention belongs to the field of software architecture quality evaluation facing to micro-service source files in software static detection, and provides a preprocessing method for partitioning the micro-service source files based on a rule configuration mode.
Technical Field
The current micro-service architecture is used as an emerging software architecture to gradually replace the traditional software architecture, so that the micro-service architecture becomes a more effective solution to the complex problem, more and more internet enterprises are transforming from the traditional architecture to the micro-service architecture, and more than half of new projects are indicated to adopt the micro-service architecture in a micro-service maturity status report issued by Neal Ford in 2018. Compared with the traditional architecture, the micro-service architecture splits the whole service into a plurality of sub-services, and each sub-service appears as a separate service, so that the whole project is flexible and easy to expand, and more complex requirements can be realized.
With the increase of the micro service project scale, the micro service architecture-oriented evaluation work is more important, and meanwhile, as the complexity of the micro service architecture is far higher than that of the traditional single application, the evaluation difficulty is greatly improved, and the traditional evaluation method lacks pertinence, so that the micro service architecture is difficult to evaluate comprehensively.
The static analysis of the source code level on the micro-service project can generally effectively acquire various index information of the architecture, and has important significance on the evaluation of the micro-service architecture. For example, mazlami et al analyze source code and change history 2 According to the association of the logic, the semantic and other aspects of the codes, a coupling relation diagram among classes is generated, and finally sub-services of the micro-service items are effectively analyzed and split by clustering the diagram.
Although the method for carrying out static analysis on the source code has higher practicability, in view of the complexity of the micro-service architecture, the source code of the software project developed by adopting the micro-service architecture is more complex and various in form, so that huge workload is brought when the source code is subjected to static detection, and a large amount of repeatability is possibly brought due to the characteristics of the static detection technology, which is not beneficial to the evaluation of the architecture. The invention provides a rule-based micro-service source file preprocessing method before project evaluation, which can extract key information used for evaluation as much as possible when single static detection traversal is carried out, and solves some common problems when static detection is carried out on micro-service project source codes.
Disclosure of Invention
The invention aims to provide a method for converting a micro-service item source file with various forms and difficult processing into a form with uniform format and easy processing, which realizes and controls the preprocessing process of the micro-service source file in a configurable way.
The invention mainly comprises three processing components, namely a filter for eliminating interference items, a marker for marking and classifying and a divider for controlling splitting granularity. In response, each processor has a corresponding set of rules to control the execution of the processor. The following is a detailed description:
1. processing assembly
1) Filter device
The filter is used to determine which files or directories need to be scanned. The process discards files or directories that have no sense of detection based on the rules of filtering, thereby reducing the workload of a single pass.
2) Marking device
The marker is used for classifying and marking files in the micro-service items. The process creates a corresponding entity object for each file or directory meeting the rule based on the marked rule and places the entity objects of the same class in the containers of the same class with the same label.
3) Dividing device
The divider is used for splitting the micro-service item source file. The process divides the entire micro-service item into several sub-granularities based on the rule of division, typically the subsequent evaluation process for each sub-service should be identical for the micro-service item, so each sub-granularity should correspond to one sub-service for the subsequent iterative evaluation process.
2. Workflow process
Based on the rules of configuration (used to guide the manner in which the processing components operate, described using structured language, such as xml), the workflow and steps of the present invention are as follows: a rule-based micro-service source file preprocessing method specifically comprises the following steps:
step 1), taking a root directory of a micro-service item source file as input, scanning the directory in a recursion traversal mode, and entering step 2 in an iterative processing mode when one directory or file is scanned;
step 2) configuring rules controlling the operation of the filter, wherein the rules indicate which files need to be filtered. Taking each scanned directory or file as the input of a filter, selecting the file to be discarded or continuously processed by the filter according to the configuration item, entering the step 3 only by selecting the continuously processed file, otherwise, returning to the step 1 for re-iteration;
step 3) configuring rules for controlling the operation of the marker, wherein the rules specify a method for marking a specific file. The method comprises the steps that a catalog or a file obtained from a filter is used as input, the input is matched with a marking rule, if the input is successfully matched, the file or the catalog is marked, a plurality of files or catalogs belonging to one mark are divided into one type, finally, mark mapping information and corresponding mark entities are obtained, and the mark entities record detailed information about the marked catalog or file;
step 4) configuring rules controlling the operation of the divider, the rules specifying the method of splitting a micro-service item. Taking a catalog or a file obtained from a filter as input, dividing the catalog into a granularity, and marking the granularity to obtain corresponding granularity mapping information and granularity entity, wherein the granularity entity records detailed information of the sub-service corresponding to the granularity if the input meets the dividing rule;
step 5) combining the mark mapping information, the mark entity, the granularity mapping information and the granularity entity obtained in the processing process into a corresponding mapping table and entity set as the result of the preprocessing process, then judging whether all the catalogues or files are preprocessed, if yes, entering into step 6 to finish the whole preprocessing process, if not, returning to step 1 again to continue iterating the unprocessed catalogues or files, wherein the rule configuration process is only carried out in the first iteration, and the same set of rules are used in the subsequent iteration process;
and 6) taking the finally combined mapping table and entity set as the output of the whole preprocessing process, and providing a read interface.
Compared with the prior art, the invention has the following beneficial effects: the invention provides a complete preprocessing process of the micro service project source file, which is used for solving some common problems when evaluating the micro service project framework in static detection. The static evaluation of the software architecture based on the invention has the following advantages:
(1) The efficiency of static detection of the micro-service project is improved, the evaluation of the static detection efficiency is often dependent on the traversing frequency of the static detection, the static detection efficiency and the traversing frequency belong to a negative correlation relationship, and when iteration traversal is frequently carried out on a project source file, the detection efficiency is not high easily, and a large number of repeated detection works are carried out. Throughout the whole preprocessing process in the invention, only one iteration traversing process is carried out, the preprocessing principle is to find and extract as much information possibly related in the subsequent evaluation process as possible and cache path information, and when the information is needed, the information can be obtained only with the time complexity of O (1) without traversing each time. In addition, the filter reduces the workload of single traversal and discards a large amount of irrelevant file information;
(2) In order to facilitate the extraction of the evaluation information of the micro service item, the whole micro service item should not be regarded as a whole, but rather should be regarded as a set of several sub services, which is also one of the important characteristics of the micro service item, so the invention provides a rule-based partitioning method, which splits the whole micro service item into sub granularity sets, one granularity corresponding to one sub service, so that the evaluation process can be readjusted into the process of iterative evaluation in units of sub services. The method and the system for analyzing the configuration files of the micro service have the advantages that information needed in the construction evaluation of the micro service items is often more than one type, and particularly for the deployment micro service items, a large number of configuration files are needed to be analyzed to obtain corresponding deployment information;
(3) This rule-based configuration allows the preprocessing program to be very versatile and generic in facing different microservices items. Generally, even if two independent projects are each implemented with a micro-service architecture, the organization and structure of their project source files may be quite different, even though they may fulfill the same requirements. This generally directly affects the ease of static resolution, increasing the complexity of the evaluation process. The invention provides a reasonable solution, a user only needs to design corresponding preprocessing rules based on the characteristics and the organization mode of the target microservice project source file, the preprocessing process can be automatically carried out according to the corresponding rules, thus the subsequent evaluation process can acquire information required by evaluation in a mode independent of the project source file, and a set of solution is not needed to be designed for specific projects.
Drawings
FIG. 1 is a schematic representation of a rule in the present invention;
fig. 2 is a preprocessing flow chart of the present invention.
Detailed Description
According to the invention, a group of rules are determined by analyzing the organization mode of the target micro-service project source file, the rules are used for controlling the preprocessing execution process, the functions of source file filtering, code classification and project splitting are realized, favorable conditions are created for the subsequent micro-service architecture evaluation process based on the static detection technology, and meanwhile, the evaluation process can be performed without paying attention to the difference of file organization modes among the micro-service projects through the rule configuration mode.
For the purpose of enhancing the understanding and appreciation of the present invention, the following detailed description of the technical aspects of the present invention is provided in connection with the accompanying drawings: examples: the scheme mainly details the invention through two aspects, the first part is the configuration mode of the rules in the invention and how to drive the execution of the corresponding processor through the configured rules, and the second part is the execution process of the whole preprocessing program, and mainly relates to the data circulation and the interaction mode of data among components.
1. Rules and components
Fig. 1 illustrates a core concept, namely rules, in the present invention. The rule is used for specifying a specific working mode of the processor, and the invention independently extracts the part which changes along with the different target micro-service items in the preprocessing process as the rule so as to realize universality of the preprocessing method.
The invention relates to three rules, namely a filtering rule, a marking rule and a dividing rule. Specific functions are accomplished by the cooperation of rules and corresponding components, and the implementation process and principle are described separately below:
1) Filtering rules and filters
The filtering rules of the filter mainly comprise two rules, including a containing rule and an excluding rule, and the rules are described in an XML configuration mode, and the content is as follows:
the rule is used for deciding which files or directories the filter needs to discard, when an input enters the filter, the filter reads the regular expression in the rule exclude label and then matches the input content, and if the matching is successful, the file is discarded. Another rule is an inclusion rule that specifies files that the filter allows to pass, the priority of which is lower than the exclusion rule, and the content of the inclusion rule is typically x, i.e., can match any input, and should be prioritized when most files need to be excluded.
2) Marking rules and markers
The marking rule is used for specifying which files should belong to the same class and plays a role of path caching, and the contents are as follows:
the marking rules are specified by a set of tag labels, each tag represents a type of file or directory, each tag contains a type ID and a set of rules, when an input successfully matches a rule, the marker creates a marking entity corresponding to the input, and the marking entity has three attributes including a type identifier corresponding to the entity, input path information and granularity ID to which the entity belongs, which need to be obtained from the divider. Here, one Map object and several List objects may be used to store the content output by the marker, and each time a marker entity is obtained, it is stored in a corresponding List set, and when a certain type of file is needed, the type may be quickly obtained from the Map object by using the type as a key.
3) Division rule and division
The partitioning rule is used to partition the whole micro-service item into sub-granularity sets, each granularity corresponds to one sub-service, which is beneficial to the subsequent iterative detection of the sub-service, and the content is as follows:
in the micro-service item, the sub-service is externally displayed as an independent item from the aspect of file organization, and the condition that two sub-services belong to the same item does not exist, so that each independent item can be considered to be classified into a granularity when the granularity is divided, each item usually contains a source code storage directory src and a plurality of specific configuration files, therefore, the matching mode can be set to match the sub-directory contained in the input, if the specific item is contained, the sub-service is defaulted to be src, the divider creates a corresponding granularity entity, the entity contains a unique granularity ID, file path information and a plurality of descriptive information related to the sub-service, the divider identifies the directory and the sub-directory corresponding to the input to prevent further division of the granularity, then the sub-service name is used as a key, and the granularity entity is stored into a mapping table as a value, so that each sub-service can be evaluated according to the information in the mapping table in the evaluation process.
2. Execution process
Fig. 2 shows the whole preprocessing flow, the input of the whole preprocessing is the root directory of the source code of the micro service item, and the output is the marked entity set, the marked mapping table, the granularity entity set and the granularity mapping table. A rule-based micro-service source file preprocessing method, the method comprising the steps of: the specific implementation process is as follows:
step 1) executing a scanning process, defining cur as current input, defining cur as a root directory of the source code of the whole micro-service project at the first scanning, defining a function scan (cur) as a function for realizing the scanner, and returning to the next node in the project directory tree relative to cur in the depth-first traversal order by calling the function. Redefining cur as a function return value after the scan function is executed, and transmitting the function return value to a subsequent process.
Step 2) executing a filtering process, and defining a function filter (run) to realize the function of the filter, wherein the run represents a rule read from a configuration file, the rule can read a rule related to the filter, if the rule is allowed to pass, the operation after execution is returned to true, otherwise, the execution process is terminated by returning to false, and the step 1 is resumed.
Step 3) performing a marking process, defining a function mark (cursor, rule, & markMap) to implement the function of the marker, wherein rules related to the marker can be read from the rule, and a markMap object is introduced, the object representing a marker mapping table, and the marker adds marker information to the table.
Step 4) executing the partitioning process, defining a function divide (cursor, rule, and the rule can read the rule about the divider and input a granulitymap object, and if the function creates a granularity entity in the executing process, adding the granularity entity to the object.
Step 5) a decision process for judging whether all nodes in the directory tree have been traversed, if cur is the last node, entering step 6 to complete the preprocessing, otherwise returning to step 1 to continue processing the next node.
Step 6) a final output procedure, which indicates that the preprocessing procedure has been performed, defining the functions get MarkMap () and getgranulitymap () as methods of reading the tag mapping table and the granularity mapping table, and being called by the subsequent evaluation procedure.
Specific examples:
the following examples are assumed:
there is an item P belonging to a micro-service architecture, where path functions are used to obtain path information for an item or sub-item. The present example aims at outputting a set of marked entities, a marked mapping table, and a set of granularity entities, a granularity mapping table through a preprocessor given a path (P) as input.
The method comprises the steps of analyzing a file organization mode of a project P, selecting a code organization mode adopted by most of current micro-service project development, wherein a development language used by the project P is Java, a package construction tool is Maven, the micro-service project development is carried out based on a SpringCloud framework, sub-services belonging to the same business function module are divided into the same directory, namely three existing forms are available for one directory, and the three existing forms can be a set of a plurality of sub-services, can be a root directory of a certain sub-service or belong to a certain sub-service. Each sub-service is a separate java project.
According to the aforementioned execution steps, the following steps are performed in sequence:
1) When scanning for the first time, the current processing directory needs to be initialized to the root path of the item P, and in the subsequent iteration process, the current processing directory is a file or directory path which is iterated, and belongs to the subdirectory of the item P.
2) For simplifying the example, only one filtering rule is added to filter the test file, and for general java engineering, there is a test directory under the src directory, and the test directory is usually used for testing based on the Junit correlation, so that the evaluation significance is less, and the test file is not scanned, and the rule is excluded as follows:
^.*/src/test/$
the filter executes the filter, and when the cur is the test directory, i.e. matches the test path, the directory and all files below the directory will be ignored at this time, otherwise the preprocessing process continues.
3) The marking rule is configured, only the configuration files about springgroup in the sub-service are marked and categorized, and the configuration files are usually located under the resources directory, and a unique identifier of the class needs to be given when the configuration files are marked, and the configuration files are set as 'springgroup-settings', and the specific matching rule is as follows:
((application)|(bootstrap))\\.((properties)|(yml))
the marker executes mark (cur, rules, & MarkMap), when cur is a configuration file related to spring group, such as application. Yml, a mark entity is created to record the file, the file is cached, a set with a key name of spring group-settings is fetched from the MarkMap, if the mark entity is added for the first time, an empty mark entity set needs to be created, and then the mark entity is added to the set.
4) The partitioning rule is configured, and the partitioning rule is mainly used for distinguishing the category of the directory included in the current directory, the rule is analyzed aiming at the subdirectories included in the current directory, and the matching rule is simpler, as follows:
^.*/(\\w+)？/src/$
when the matching rule is inaccurate, the same class of rule may continue to be added to limit the matching condition. The divider executes a divide (cur, rules, & granulitymap), and when cur is a directory, it needs to search its primary subdirectory, if the primary subdirectory of cur meets the condition, i.e. in this example, contains the src directory, it is regarded as a sub-service, and typically, the pon file is also located in this directory, and may be added to the rule to strengthen the constraint, and then a unique identifier is generated for this sub-service and a granularity entity is added to the granulitymap.
5) And (3) obtaining all information of the iterative process, if all the subdirectories of the item P are iterated, entering a step 6 to finish the preprocessing process, otherwise, returning to the step 1 again to continue iteration.
6) After traversing all files or directories of the project, obtaining a marked entity object, such as SettingA, settingB, settingN, belonging to the spring group-set category from the markMap object in the example, and obtaining a sub-service entity object, such as ServiceA, serviceB, serviceN, about the project P from the granular map object.
It should be noted that the above-mentioned embodiments are merely preferred embodiments of the present invention, and are not intended to limit the scope of the present invention, and equivalent substitutions or alternatives made on the basis of the above-mentioned technical solutions are all included in the scope of the present invention.
Claims (7)
1. A method for preprocessing a micro-service source file based on rules, the method comprising the steps of:
step 1: performing a scanning process;
step 2: performing a filtering process;
step 3: performing a marking process;
step 4: executing a dividing process;
step 5: a decision process;
step 6: a final output process;
step 1, taking a root directory of a micro-service item source file as an input, scanning the directory in a recursion traversal mode, and entering step 2 in an iterative processing mode when one directory is scanned or a file is scanned;
step 2, configuring rules for controlling the operation of a filter, wherein the rules indicate which files need to be filtered, each scanned directory or file is used as the input of the filter, the filter selects to discard or continue processing the file according to configuration items, only the file which is selected to continue processing can enter the step 3, otherwise, the step 1 is returned to for re-iteration;
step 3, configuring a rule for controlling the operation of a marker, wherein the rule indicates a method for marking a specific file, a catalog or a file obtained from a filter is used as input, the input is matched with the marked rule, if the matching is successful, the file or the catalog is marked, a plurality of files or catalogs belonging to one mark are classified into one type, finally, mark mapping information and corresponding marking entities are obtained, and the marking entities record detailed information about the marked catalog or file;
step 4, configuring rules for controlling the operation of the divider, wherein the rules indicate a method for splitting a micro-service item, taking a catalog or a file obtained from a filter as input, dividing the catalog into a granularity if the input meets the dividing rules, and identifying the granularity as a sub-service for the micro-service item to obtain corresponding granularity mapping information and granularity entity, wherein the granularity entity records detailed information of the sub-service corresponding to the granularity;
step 5, combining the mark mapping information, the mark entity, the granularity mapping information and the granularity entity obtained in the processing process into a corresponding mapping table and entity set as the result of the preprocessing process, then judging whether all the catalogues or files are preprocessed, if so, entering into step 6 to finish the whole preprocessing process, otherwise, returning to step 1 again to continue iterating the unprocessed catalogues or files, and configuring the rule process only in the first iteration, wherein the same set of rules are used in the subsequent iteration process;
step 6, taking the mapping table and the entity set which are finally obtained by combination as the output of the whole preprocessing process, and providing a read interface;
the method mainly comprises three processing components, namely a filter for eliminating interference items, a marker for marking and classifying and a divider for controlling splitting granularity,
1) And (3) a filter:
the filter is used for deciding which files or directories need to be scanned, and the process discards files or directories without detection significance based on the filtering rule, so that the workload of single traversal is reduced;
2) The marker comprises:
the marker is used for classifying and marking files in the micro-service project, the process is based on marked rules, creates corresponding entity objects for each file or catalogue meeting the rules, and places the entity objects of the same class in containers of the same class by marking the same labels;
3) A divider:
the divider is used to split the micro-service item source file, the process divides the entire micro-service item into several sub-granularities based on the rules of the division, for the micro-service item, the subsequent evaluation process for each sub-service should be identical, so each sub-granularity should correspond to one sub-service for the subsequent iterative evaluation process.
2. The rule-based micro-service source file preprocessing method according to claim 1, wherein step 1: the scanning process is performed as follows: defining cur as current input, defining cur as root directory of whole micro service project source code when scanning for the first time, defining function scan (cur) as function of realizing scanner, calling the function to return to next node corresponding to cur in sequence of depth priority traversal in project directory tree, redefining cur as function return value after executing scan function, and transferring to follow-up process.
3. The rule-based micro-service source file preprocessing method according to claim 2, wherein step 2: the filtering process is performed as follows: defining a function filter (rules) to realize the function of the filter, wherein the rules represent rules read from the configuration file, the rules can be read from the rules related to the filter, if the rules are allowed to pass, the operations after the execution are returned to true, otherwise, the execution process is terminated by returning to false, and the step 1 is returned again.
4. A method of preprocessing a rule-based microservice source file according to claim 3, characterized by step 3: the marking process is performed as follows: the function mark (cur, rules, & markMap) is defined to implement the function of the marker, wherein rules related to the marker can be read from the rules and a markMap object is entered, which represents a marker mapping table to which the marker will add marker information.
5. A method of preprocessing a rule-based microservice source file according to claim 3, characterized by step 4: the partitioning process is performed as follows: defining a function divide (cursor, rules) to implement the function of the divider, wherein the rules can read rules about the divider and input a granulitymap object, and if the definition function creates a granularity entity in the execution process, the definition function is added to the object.
6. A method of preprocessing a rule-based microservice source file according to claim 3, characterized by step 5: the decision process is as follows: the process is used for judging whether all nodes in the directory tree are traversed, if the cur is the last node, the step 6 is entered to complete the preprocessing, otherwise, the step 1 is returned to again to continue to process the next node.
7. A method of preprocessing a rule-based microservice source file according to claim 3, characterized by step 6: the final output process is specifically as follows: this procedure indicates that the preprocessing procedure has been performed, and functions get MarkMap () and getgranulitymap () are defined as methods of reading the tag mapping table and the granularity mapping table, which are called by the subsequent evaluation procedure.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110587637.5A CN113268425B (en) | 2021-05-27 | 2021-05-27 | Rule-based micro-service source file preprocessing method |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110587637.5A CN113268425B (en) | 2021-05-27 | 2021-05-27 | Rule-based micro-service source file preprocessing method |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN113268425A CN113268425A (en) | 2021-08-17 |
| CN113268425B true CN113268425B (en) | 2024-03-22 |
Family
ID=77233512
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202110587637.5A Active CN113268425B (en) | 2021-05-27 | 2021-05-27 | Rule-based micro-service source file preprocessing method |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN113268425B (en) |
Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN104156307A (en) * | 2014-07-03 | 2014-11-19 | 安徽景行信息科技有限公司 | Browser compatibility detecting method and system |
| WO2017067230A1 (en) * | 2015-10-21 | 2017-04-27 | 中兴通讯股份有限公司 | Software function expansion method and apparatus based on micro service architecture |
| CN112333096A (en) * | 2020-10-16 | 2021-02-05 | 济南浪潮数据技术有限公司 | Micro-service traffic scheduling method and related components |
| CN112579436A (en) * | 2020-12-01 | 2021-03-30 | 中国科学院电子学研究所苏州研究院 | Micro-service software architecture identification and measurement method |
-
2021
- 2021-05-27 CN CN202110587637.5A patent/CN113268425B/en active Active
Patent Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN104156307A (en) * | 2014-07-03 | 2014-11-19 | 安徽景行信息科技有限公司 | Browser compatibility detecting method and system |
| WO2017067230A1 (en) * | 2015-10-21 | 2017-04-27 | 中兴通讯股份有限公司 | Software function expansion method and apparatus based on micro service architecture |
| CN106612188A (en) * | 2015-10-21 | 2017-05-03 | 中兴通讯股份有限公司 | Method and device for extending software function based on micro service architecture |
| CN112333096A (en) * | 2020-10-16 | 2021-02-05 | 济南浪潮数据技术有限公司 | Micro-service traffic scheduling method and related components |
| CN112579436A (en) * | 2020-12-01 | 2021-03-30 | 中国科学院电子学研究所苏州研究院 | Micro-service software architecture identification and measurement method |
Non-Patent Citations (2)
| Title |
|---|
| 微服务架构的发展与影响分析;李贞昊;;信息系统工程;20170120(01);全文 * |
| 王璐璐.一种面向有环兴趣路径的过程内剖析方法.《计算机学报》.2014,全文. * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN113268425A (en) | 2021-08-17 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN110245496B (en) | Source code vulnerability detection method and detector and training method and system thereof | |
| CN107704265B (en) | Configurable rule generation method for service flow | |
| CN107644323B (en) | Intelligent auditing system for business flow | |
| US8612939B2 (en) | Multi trace parser | |
| JP5899946B2 (en) | Dividing device, dividing method, and dividing program | |
| AU2013329525B2 (en) | System and method for recursively traversing the internet and other sources to identify, gather, curate, adjudicate, and qualify business identity and related data | |
| CN109344230A (en) | Code library file generation, code search, connection, optimization and transplantation method | |
| KR101355273B1 (en) | A computing system, a method for controlling thereof, and a computer-readable recording medium having a computer program for controlling thereof | |
| JP2012098797A (en) | Method for producing rule for classifying structured documents, computer program therefor and computer | |
| US9158599B2 (en) | Programming framework for applications | |
| KR20060104505A (en) | Universal string analyzer and method thereof | |
| CN111913693A (en) | Method and system for determining subclass template of service interface | |
| CN115358200A (en) | Template document automatic generation method based on SysML meta model | |
| Petermann et al. | Graph mining for complex data analytics | |
| US10360208B2 (en) | Method and system of process reconstruction | |
| CN113268425B (en) | Rule-based micro-service source file preprocessing method | |
| KR20050070955A (en) | Method of scientific information analysis and media that can record computer program thereof | |
| Garris et al. | NIST Scoring Package User’s Guide | |
| CN111159230A (en) | Data resource map construction method and device, storage medium and terminal | |
| CN115374242A (en) | Self-defined field and template low-code system for unstructured compound identity order | |
| CN113342749A (en) | File path matching method, device, equipment and computer readable storage medium | |
| KR20220095654A (en) | Social data collection and analysis system | |
| JP6677624B2 (en) | Analysis apparatus, analysis method, and analysis program | |
| CN115168399B (en) | Data processing method, device and equipment based on graphical interface and storage medium | |
| CN117454851B (en) | PDF document-oriented form data extraction method and device |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |