CN117492723A - Automatic industrial software code generation method based on data and behavior model - Google Patents
Automatic industrial software code generation method based on data and behavior model Download PDFInfo
- Publication number
- CN117492723A CN117492723A CN202210859360.1A CN202210859360A CN117492723A CN 117492723 A CN117492723 A CN 117492723A CN 202210859360 A CN202210859360 A CN 202210859360A CN 117492723 A CN117492723 A CN 117492723A
- Authority
- CN
- China
- Prior art keywords
- data
- model
- code
- behavior
- establishing
- 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.)
- Pending
Links
- 238000000034 method Methods 0.000 title claims abstract description 33
- 238000012545 processing Methods 0.000 claims abstract description 68
- 230000006399 behavior Effects 0.000 claims abstract description 42
- 238000013507 mapping Methods 0.000 claims abstract description 23
- 230000000694 effects Effects 0.000 claims description 42
- 238000004458 analytical method Methods 0.000 claims description 17
- 238000007726 management method Methods 0.000 claims description 15
- 238000013500 data storage Methods 0.000 claims description 11
- 230000006870 function Effects 0.000 claims description 11
- 238000013499 data model Methods 0.000 claims description 9
- 230000003993 interaction Effects 0.000 claims description 9
- 230000007246 mechanism Effects 0.000 claims description 9
- 230000001502 supplementing effect Effects 0.000 claims description 6
- 238000010276 construction Methods 0.000 claims description 5
- 238000007405 data analysis Methods 0.000 claims description 4
- 238000013145 classification model Methods 0.000 claims description 3
- 238000000354 decomposition reaction Methods 0.000 claims description 3
- 238000010586 diagram Methods 0.000 claims description 3
- 230000002452 interceptive effect Effects 0.000 claims description 2
- 239000013589 supplement Substances 0.000 claims description 2
- 238000011161 development Methods 0.000 abstract description 18
- 238000006243 chemical reaction Methods 0.000 description 6
- 238000005192 partition Methods 0.000 description 5
- 238000005516 engineering process Methods 0.000 description 4
- 230000008569 process Effects 0.000 description 4
- 238000000605 extraction Methods 0.000 description 3
- 230000002776 aggregation Effects 0.000 description 2
- 238000004220 aggregation Methods 0.000 description 2
- 238000003491 array Methods 0.000 description 2
- 230000008859 change Effects 0.000 description 2
- 238000013461 design Methods 0.000 description 2
- 238000005538 encapsulation Methods 0.000 description 2
- 230000002708 enhancing effect Effects 0.000 description 2
- 230000008676 import Effects 0.000 description 2
- 239000000463 material Substances 0.000 description 2
- 239000003607 modifier Substances 0.000 description 2
- 101100123444 Schizosaccharomyces pombe (strain 972 / ATCC 24843) hap5 gene Proteins 0.000 description 1
- 230000009471 action Effects 0.000 description 1
- 238000013459 approach Methods 0.000 description 1
- 230000009286 beneficial effect Effects 0.000 description 1
- 239000003795 chemical substances by application Substances 0.000 description 1
- 238000012790 confirmation Methods 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
- 238000002955 isolation Methods 0.000 description 1
- 238000012544 monitoring process Methods 0.000 description 1
- 230000008520 organization Effects 0.000 description 1
- 239000000047 product Substances 0.000 description 1
- 230000003252 repetitive effect Effects 0.000 description 1
- 238000011160 research Methods 0.000 description 1
- 239000010979 ruby Substances 0.000 description 1
- 229910001750 ruby Inorganic materials 0.000 description 1
- 230000035945 sensitivity Effects 0.000 description 1
- 238000000926 separation method Methods 0.000 description 1
- 238000006467 substitution reaction Methods 0.000 description 1
- 238000012360 testing method Methods 0.000 description 1
- 238000012546 transfer Methods 0.000 description 1
- 230000009466 transformation Effects 0.000 description 1
- 230000001960 triggered effect Effects 0.000 description 1
- 238000012795 verification Methods 0.000 description 1
- 238000009941 weaving Methods 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/10—Requirements analysis; Specification techniques
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
- G06F8/44—Encoding
- G06F8/447—Target code generation
Landscapes
- Engineering & Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Software Systems (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Devices For Executing Special Programs (AREA)
Abstract
The invention relates to an automatic generation method of industrial software codes based on data and a behavior model, which comprises the following steps: carrying out multi-view top-layer demand modeling based on model system engineering; extracting data and feature definitions of behaviors; constructing an industrial software data behavior processing model; constructing a platform-independent data processing structure and establishing a characteristic relation rule engine; generating an information template and a code template; establishing a configuration strategy of a multi-target language based on the object-oriented language; establishing a code mapping rule; an automatic code generation engine is constructed to generate object code. The invention can provide model definition and code generation oriented to data and behavior processing, and can automatically generate a code frame, data processing and behavior processing codes of an industrial software complex data processing system by adopting the method, thereby effectively reducing the error rate of manually writing codes, guaranteeing the safety and reliability of data processing code development, improving the development efficiency and reducing the development cost.
Description
Technical Field
The invention relates to the field of industrial software, in particular to an automatic industrial software code generation method based on data and a behavior model.
Background
Industrial software is an important tool for upgrading, reducing cost and enhancing efficiency in the industrial development process, and relates to a large number of data models and complex data processing, so that the industrial software in China mostly depends on import at present, and a large amount of manpower and material resources are required to be input for autonomous development of the industrial software to realize a huge data processing system. Complex data processing systems involve a number of different data models and data processing mechanisms, and when such systems are developed, the complexity of the development process and the organization team of the development rises dramatically, wherein some data models are similar, and sometimes a great deal of work by developers is spent in repetitive development, and an automatic code generation tool is needed to improve the working efficiency.
The current automatic code generation methods include four types:
(1) Code generation based on object relationships
The technology is suitable for the project of the relational database framework, and the large-scale Internet realizes framework codes by using the technology at present, such as IBM Websphere service framework, hibenate framework, spring framework, microsoft Net framework and the like. By explaining the relational database model, the functions of reading and writing of the database are packaged, a frame structure is generated, and an external access interface is provided. This approach is only applicable to systems where relational data models have been built and only provides code generation in relation to databases, failing to meet the code generation requirements in terms of function and behavior control.
(2) Contract-based code generation
Based on object-oriented basis, extending to tangent plane programming, that is, through service separation, reducing the coupling of service logic, a representative tool comprises an AOP mode of a Spring framework, a transverse extraction mechanism is adopted to replace the repeated codes (performance monitoring, object management, security check and caching) of a traditional longitudinal inheritance system, common behaviors are extracted, each common behavior (transverse attention point) can be configured into a notification, and the notification can be executed in a required place by utilizing a dynamic agent, wherein the execution place is called a 'cut-in point', and the notification and the cut-in point form a tangent plane. Such "cutting" of longitudinally encapsulated objects "then" weaving in "notification may improve the reusability and reliability of the procedure. The generation mode has slightly lower performance, is only suitable for method call, and must be implemented in a Spring container. In addition, there is Microsoft's VS extension tool Code Contracts for NET, which is more suitable for the scenario of unit testing. There is currently no suitable tool for industrial software code generation.
(3) Model-based code generation
Model-based code generation firstly abstracts software into a model, then converts the model into codes according to the mapping relation between the model and the codes, and represents tools AndroMDA and Trufun. AndroMDA can generate a deployable application program and other components according to UML model, such as a system capable of directly generating a struts+spring+hibernate architecture, and the system is supported by BPM4Struts, JBPM, JSF, EJB, hibernate, javaMeta, spring, webServic. The Trufun product provides a generic MDA code generation framework based generation language implementation: java, C#, ansiC++, delphi, perl, php5, python, database, ruby, hibernate are currently supported. The code generation based on the model has high working efficiency and changed application range, but the formed mature framework is mostly more suitable for constructing systems such as database processing, MVC, web and the like, is widely applied in the field of Internet, and does not have mature framework tools in the field of industrial control at present.
(4) Template-based code generation
The code generation based on the template comprises two types, wherein the first type is a front-end code, belongs to the code generation mode which is the simplest and the most widely applied at present, and the front-end code generation is the code generation of a vue-cli scaffold and a create-reaction-app scaffold, and is respectively based on one-key initialization project generation codes carried out by vue and a reaction framework. The development mode is simple, but the code repetition rate is high, the application range is limited to the web framework, and the method is not suitable for industrial software.
The second is the generic programming of C++ and java, which is combined with the template engine through a programmable data model, i.e. combining the variable part with the invariable part, and finally generating the target specific code. Representative tools such as sensitivity provide the ability for a user to customize templates with which the user can generate various types of source code from critical information data. However, the vector is only suitable for JAVA language, industrial software is mostly developed by adopting C or C++, and no related tool industrial software field exists at present.
The invention aims to model the data and behavior of industrial software based on model system engineering (MBSE), and provides an automatic industrial software code generation method based on the data and behavior model, which improves the code development efficiency of industrial software in the industrial control field.
Disclosure of Invention
The invention provides an automatic generation method of industrial software codes based on data and a behavior model, which aims to solve the problems in the background technology.
In order to achieve the above purpose, the present invention provides the following technical solutions:
an automatic generation method of industrial software codes based on data and behavior models comprises the following steps:
step 1: carrying out multi-view top-layer demand modeling based on model system engineering: based on model system engineering (MBSE), multi-view top-level demand modeling is carried out on data and behaviors of an industrial software complex data processing system, and data, operation and logic analysis models are realized;
step 2: feature definition of extracted data and behavior: extracting the feature definition of data and behaviors by adopting a field driving model, and realizing data, dynamic, behavior, regional function and interactive modeling;
step 3: building an industrial software data behavior processing model: designing a data storage, activity management and task operation mechanism, and constructing an industrial software data behavior processing model;
step 4: establishing a characteristic relation rule engine: adopting a JSON format to construct a platform-independent data processing structure, and establishing a characteristic relation rule engine;
step 5: generating an information template and a code template: converting the JSON format into a relational data model to generate an information template and a code template;
step 6: establishing a configuration strategy of a multi-target language based on the object-oriented language;
step 7: establishing code mapping rules: establishing code mapping rules of entities, data, activities, data flows, tasks, scenes and structured intermediate models;
step 8: constructing an automatic code generation engine: in combination with the structured data behavior model and the code mapping rules, an automatic code generation engine is built to generate object code.
The step 1 specifically comprises the following sub-steps:
step 11: modeling the requirements of the complex data processing system by adopting a requirement graph of modeling language;
step 12: extracting data processing sets such as entities, activities, tasks, data flows, scenes, interfaces and the like in a system through data analysis, operation analysis and logic analysis three-layer decomposition;
step 13: performing model construction of data, dynamics, behaviors, characteristics, functions and interactions;
step 14: and forming a requirement case set which can be used for extracting uniformly processable features and personalized feature sets.
The step 2 of extracting data and defining the characteristics of behaviors specifically comprises the following sub-steps:
step 21: constructing a characteristic relation model according to the analyzed and established demand model, the business relation of complex data processing and the field knowledge of industrial software;
step 22: combining the demand model, extracting application characteristics of data, designing a corresponding data processing strategy, and realizing a hierarchical data storage structure;
step 23: based on the data processing structure, realizing activity management and task operation mechanism, matching layering of the data storage structure, combining with a scene and an interface, realizing resource data service management, and designing a data storage strategy through a classification model;
step 24: and designing access interfaces of different classified data by utilizing the data flow diagram, and providing an index and query method of data access.
The step 3 specifically comprises the following sub-steps:
step 31: designing a management mode, a feature dictionary and an access mode of data processing based on the scene set and the feature set;
step 32: according to the scene set, carrying out partition domain processing on the complex processing service, and constructing a scene for partition of which the single-function task exceeds 1000;
step 33: dividing the multi-activity data into data and data streams according to activities by dividing the scene into tasks, and forming storage data elements;
step 34: from the view of the scene, constructing an independent access mode of single scene data; constructing a task-based resource service management structure from a task perspective;
step 35: and realizing data access by adopting a relational database, and establishing a data processing management and access mode by combining a relational database splitting and table splitting mode.
The step 4 specifically comprises the following sub-steps:
step 41: converting unstructured requirements into structured definitions, converting a description mode of unstructured data of a requirement model into structured data which can be understood by a computer, and completing definition of the structured data by adopting a JSON format, so as to convert the structured data into structured data which can be defined in a database;
step 42: and a unified feature model is constructed through the feature dictionary set, so that processing strategies such as mapping, association, range and the like of data processing can be realized.
The step 6 comprises the following sub-steps:
step 61: based on three object-oriented languages of C++, java and C#, a configuration template of a programming language is established, and the configuration template comprises strategy configuration such as development environment, basic grammar (comprising objects and classes, basic data types, variable types, modifiers, operators, loop structures, conditional sentences and the like), private definition (arrays, date and time, methods, file operations, exception handling and the like), object-oriented (inheritance, polymorphism, abstract classes, encapsulation, interfaces, enumeration, packages and the like), high-level structure (aggregation, container, generalization, serialization, network programming, multithreading, annotation and the like) and the like;
step 62: by carrying out the immobilized code frame mapping on the strategies, the code corresponding to the target platform can be conveniently generated subsequently.
The step 8 specifically comprises the following sub-steps:
step 81: analyzing the rules and the models by reading the code mapping rules and the models defined in the relational database;
step 82: traversing the model by adopting a method combining from bottom to top and from top to bottom according to the hierarchy of the data- > activity- > task- > scene;
step 83: firstly, analyzing a scene, constructing a scene frame code, further analyzing tasks and interfaces in the scene to generate a task model, continuously obtaining information of activities in the tasks in depth, establishing a multi-activity type frame code, and finally generating a data type to obtain a frame code of the whole system;
step 84: and (3) adopting a bottom-up method, starting to supplement the detail relation between the data and the data stream from the data, further supplementing the operation and interaction processing of the activity, then supplementing the details of tasks and interfaces, and finally supplementing the detail codes in the scene.
Industrial software is an important tool for upgrading, reducing cost and enhancing efficiency in the industrial development process, and relates to a large number of data models and complex data processing, so that at present, industrial software in China mostly depends on import, and industrial software for autonomous development needs to input a large amount of manpower and material resources to realize a huge data processing system, and autonomous development needs to be assisted by an automatic means. The invention carries out multi-view top-level demand modeling and architecture design on the demands, design, analysis, verification and confirmation of the complex data processing system of industrial software based on the MBSE model system engineering theory, and realizes the model construction of the complex data processing system based on the data and behavior characteristics of the field driven extraction system; the code automatic generation tool special for complex data processing is designed by combining the relation database theory and the compiling technology, the code framework of the complex data processing system can be realized by adopting the tool, the error rate of manually writing codes is effectively reduced, the safety and reliability of data processing code development are ensured, the development efficiency is improved, and the development cost is reduced.
Drawings
FIG. 1 illustrates an automated code generation tool process flow.
FIG. 2 model based on demand analysis of MBSE.
FIG. 3 feature relationship model analysis.
Fig. 4 is based on structured data defined by Json.
FIG. 5 is a platform independent complex number processing model.
FIG. 6 automatic code generation mechanism.
Detailed Description
In order to achieve the above purpose, the present invention implements the following technical scheme:
as shown in fig. 1 to 6, the specific implementation scheme of the automatic generation method of the industrial software code based on the data and the behavior model is as follows:
the workflow is shown in figure 1, demand analysis is carried out based on model system engineering (MBSE), data and characteristic definitions of behaviors are extracted, an industrial software data behavior processing model is built, a characteristic relation rule engine is built, and a structurable data behavior model is generated; and analyzing configuration strategies of multiple target languages, establishing code mapping rules, and constructing an automatic code generation engine to generate target codes by combining a structured data behavior model.
1. Demand model construction
And carrying out demand analysis on complex system data processing based on the MBSE model, and constructing a system demand model. The complex data processing characteristics are uniformly combed, as shown in fig. 2, three layers of decomposition are performed through data analysis, operation analysis and logic analysis, data processing sets such as entities, activities, tasks, data flows, scenes and interfaces in a system are refined, data, dynamic, behavior, characteristics, functions and interaction model construction are performed, a demand case set is formed, and the method can be used for subsequently extracting uniformly processed characteristics and personalized characteristic sets.
2. Model definition
(1) Definition of the definition
The elements to be analyzed are defined according to fig. 2: data entity dx, activity act, task, data stream df, scene, interface inf.
(1) Data definition
For complex system data, the data is the core of the system, and the requirements of data modeling mainly comprise basic characteristics of data sources, types, attributes, ranges and the like, and characteristics of data targets converted according to activities, tasks and the like. Assuming that a single data entity is dx, dx is represented by a five-tuple:
for each dx, a name is defined to represent the name of the data, source represents the data source, type represents the data type, attri represents the attribute of the data, range represents the data range.
All data sets of the system are defined as:
。
(2) activity definition
Activity act is represented by a triplet:
；
a name is defined for each activity, the input data of the activityOutput data->And the task to which the activity belongs.
Then all active sets of the system are defined as。
(3) Task definition
Tasks are an active set that performs multiple activities to accomplish a particular function, then task is represented by a triplet:
；
defining a name for each task, defining an active act set of the task asThe data dx is gathered as。
Then， />。
Then the set of all tasks of the system is defined as:。
(4) data flow definition
The data stream df is represented by a triplet:
；
defining a name for each data stream, entry activity for the data streamt and Outlet Activity->。
All data flow sets of the system are defined as:
。
(5) scene definition
A scene is a combination of a set of tasks that implements a specific system function. The tasks interact with the tasks directly through the interface.
The scene is represented by a triplet:
；
defining a name for each task, defining task set in the scene asInterface inf set is +.>。
Then， />。
Then all scene sets of the system are defined as。
(6) Interface definition
Interface inf is represented by a triplet:
；
defining a name inf for each interface, the provisioning task of the interfaceInvoking tasks of the interfaceAnd the scene to which the interface belongs.
Then the set of interfaces all of the system is defined as。
(2) Data analysis
In complex data processing systems, the data set is multiple, and is a complex set due to the very many types and varying characteristics of the data.
For dataThere is the following conversion:
；
for data conversion activities, the change of data is designed according to the split of the activities, so that a huge active set exists. Further analysis will be made in the next section on how to extract the features of the active set.
Data flow is the transfer of data between two activities and is a dynamic concept.
For data flowsThere is the following conversion:
;
(3) Run analysis
An activity is a minimum computational unit triggered by an action or event in a complex data processing system, and is a notion of behavior because its actual execution is defined depending on the specific function of the business system.
For activitiesThere is the following conversion:
；
a scene is a combination of one or more sets of activities in a complex processing system, which is defined in terms of functional partitions of the business system, and thus is a regional concept.
For scenesThere is the following relationship:
(4) Logic analysis
Tasks and interfaces are modeling objects obtained by decomposing system requirements from a logic layer, and tasks are a set of activities and are a concept of functions.
For tasksThere is the following relationship:
；
the interface is an object of task-to-task interaction and is an interaction behavior concept.
For interfacesThere is the following relationship:
。
(5) Feature relation extraction
Constructing a characteristic relation model according to the analyzed and established demand model, the business relation of complex data processing and the field knowledge of industrial software, and as shown in fig. 3, extracting the application characteristics of data by combining the demand model, and designing a corresponding data processing strategy to realize a hierarchical data storage structure; based on the data processing structure, realizing activity management and task operation mechanism, matching layering of the data storage structure, combining with a scene and an interface, realizing resource data service management, and designing a data storage strategy through a classification model; and designing access interfaces of different classified data by utilizing the data flow diagram, and providing an index and query method of data access.
3. Rule engine
(1) Conversion of unstructured requirements into structured definitions
The description mode of unstructured data of the demand model is converted into structured data which can be understood by a computer, and the definition of the structured data is completed by adopting a JSON format, so that the structured data can be defined in a database, as shown in figure 4.
(2) Platform-independent complex data processing modes
Based on the Json defined structured data model, a platform-independent data processing model is constructed. As shown in fig. 5, the management mode, feature dictionary, and access mode of data processing are designed based on scene sets and feature sets. The scene set is used for carrying out partition domain processing on complex processing services and constructing scenes for partition of single-function tasks exceeding 1000; dividing the multi-activity data into data and data streams according to activities by dividing the scene into tasks, and forming storage data elements; from the view point of the scene, the data of the single scene has independent access modes; from the task point of view, the data processing of the sub-tasks is beneficial to the analysis and processing of complex data. And realizing data access by adopting a relational database, and establishing a data processing management and access mode by combining a relational database splitting and table splitting mode. Meanwhile, a unified feature model is constructed with the feature dictionary set, so that processing strategies such as mapping, association, range and the like of data processing can be realized, and automatic code generation can be conveniently carried out subsequently.
4. Model-based automatic code generation mechanism
The platform-independent data processing model is a software structure combining templatization and layering, and needs to be described in more detail. As shown in fig. 6, how to implement the generation mapping of the model and the code is a difficulty of research, so a code mapping rule needs to be designed to represent the mapping relationship between the model and the code template, which is used as a basis for code generation. Secondly, it is necessary to build configuration policies for different languages, the study is generated for object oriented language programming, the configuration policies for languages are generated by means of an object oriented generic definition based on c++, java and c#, and an automatic code generation engine is designed for generating corresponding object codes.
(1) Code mapping rules
The code mapping rules of the section are briefly described herein.
(1) Entity: and directly mapping the data structure and the object in the template to generate a class, and directly analyzing the definition in the JSON structured template to generate a corresponding class.
(2) Data: data is also an entity with a structural definition, directly defining the data in the template as a class.
(3) Activity: an activity is a transformation of data, which requires dependence on the entity, so that on the entity model, simple activity operations are turned into classes, from which new data objects may be generated.
(4) Data flow: each data stream is unidirectional, otherwise errors may be introduced.
A data stream is a local operation between two activities involving only a small number of methods or classes at a time, each data stream change requiring isolation from other data stream changes.
(5) Tasks: a task comprises a series of activities, data streams, and interfaces with other tasks. Elements such as resources, components, interfaces, operations, subtasks and the like can be redefined in the task to realize the description of the task targets.
(6) Scene: the independent services of the scenes can be directly interacted with each other, and the independent services can also be modules which are independently operated or are concurrently operated. Tasks of multiple scenarios may run concurrently. Each scene map generates a folder.
(7) Relational database: the method comprises the steps of defining a model as a structured JSON format description, enabling JSON data to serve as an intermediate model only, adding relation connection through adding interaction relation, forming template data through access management among the models, and uniformly generating the template data into a relation database. And defining the mapping relation between the programmable information template and the code template in a relation database, and determining the definition of data types, interfaces, parameters, views, areas and the like.
(2) Programming language configuration policies
The method is used for researching code generation of an object-oriented language, and a configuration template of a programming language is established based on three object-oriented languages of C++, java and C#, wherein the configuration template comprises strategy configurations such as development environment, basic grammar (comprising objects and classes, basic data types, variable types, modifiers, operators, loop structures, conditional sentences and the like), private definition (arrays, date and time, methods, file operations, exception handling and the like), object-oriented (inheritance, polymorphism, abstract classes, encapsulation, interfaces, enumeration, packages and the like), high-level structure (aggregation, containers, generalization, serialization, network programming, multithreading, annotation and the like), and the like, and the code corresponding to a target platform is convenient to generate subsequently by carrying out immobilized code frame mapping on the strategies.
(3) Automatic code generation engine
The automatic code generation engine reads the code mapping rules and the models defined in the relational database, analyzes the rules and the models, and generates specific codes according to the rules by using the models described in the relational database through a specific generation algorithm.
Considering the hierarchy of the data- > activity- > task- > scene, a bottom-up and top-down combination method is adopted to generate codes. Firstly, analyzing a scene, constructing a scene frame code, further analyzing tasks and interfaces in the scene to generate a task model, continuously obtaining information of activities in the tasks in depth, establishing a multi-activity type frame code, and finally generating a data type to obtain the frame code of the whole system. In the top-down mode, only the frame codes are generated, the bottom-up method is adopted again, the detail relation between the data and the data flow is supplemented from the data, the operation and interaction processing of the activity are supplemented, the details of the tasks and the interfaces are supplemented, and finally the detail codes in the scene are supplemented.
The above description is only specific embodiments of the present invention, but the scope of the present invention is not limited thereto, and any changes or substitutions easily come within the scope of the present invention as those skilled in the art can easily come within the scope of the present invention defined by the appended claims.
Claims (4)
1. An automatic generation method of industrial software codes based on data and behavior models is characterized by comprising the following steps:
step 1: carrying out multi-view top-layer demand modeling based on model system engineering: based on model system engineering (MBSE), multi-view top-level demand modeling is carried out on data and behaviors of an industrial software complex data processing system, and data, operation and logic analysis models are realized;
step 2: feature definition of extracted data and behavior: extracting the feature definition of data and behaviors by adopting a field driving model, and realizing data, dynamic, behavior, regional function and interactive modeling;
step 3: building an industrial software data behavior processing model: designing a data storage, activity management and task operation mechanism, and constructing an industrial software data behavior processing model;
step 4: establishing a characteristic relation rule engine: adopting a JSON format to construct a platform-independent data processing structure, and establishing a characteristic relation rule engine;
step 5: generating an information template and a code template: converting the JSON format into a relational data model to generate an information template and a code template;
step 6: establishing a configuration strategy of a multi-target language based on the object-oriented language;
step 7: establishing code mapping rules: establishing code mapping rules of entities, data, activities, data flows, tasks, scenes and structured intermediate models;
step 8: constructing an automatic code generation engine: in combination with the structured data behavior model and the code mapping rules, an automatic code generation engine is built to generate object code.
2. The multi-view top-level demand modeling based on model system engineering according to claim 1, wherein said step 1 comprises the sub-steps of:
step 11: modeling the requirements of the complex data processing system by adopting a requirement graph of modeling language;
step 12: extracting data processing sets such as entities, activities, tasks, data flows, scenes, interfaces and the like in a system through data analysis, operation analysis and logic analysis three-layer decomposition;
step 13: performing model construction of data, dynamics, behaviors, characteristics, functions and interactions;
step 14: and forming a requirement case set which can be used for extracting uniformly processable features and personalized feature sets.
3. The feature definition of extracted data and behavior according to claim 1, characterized in that said step 2 comprises the sub-steps of:
step 21: constructing a characteristic relation model according to the analyzed and established demand model, the business relation of complex data processing and the field knowledge of industrial software;
step 22: combining the demand model, extracting application characteristics of data, designing a corresponding data processing strategy, and realizing a hierarchical data storage structure;
step 23: based on the data processing structure, realizing activity management and task operation mechanism, matching layering of the data storage structure, combining with a scene and an interface, realizing resource data service management, and designing a data storage strategy through a classification model;
step 24: and designing access interfaces of different classified data by utilizing the data flow diagram, and providing an index and query method of data access.
4. The build automatic code generation engine of claim 1, wherein said step 8 comprises the sub-steps of:
step 81: analyzing the rules and the models by reading the code mapping rules and the models defined in the relational database;
step 82: traversing the model by adopting a method combining from bottom to top and from top to bottom according to the hierarchy of the data- > activity- > task- > scene;
step 83: firstly, analyzing a scene, constructing a scene frame code, further analyzing tasks and interfaces in the scene to generate a task model, continuously obtaining information of activities in the tasks in depth, establishing a multi-activity type frame code, and finally generating a data type to obtain a frame code of the whole system;
step 84: and (3) adopting a bottom-up method, starting to supplement the detail relation between the data and the data stream from the data, further supplementing the operation and interaction processing of the activity, then supplementing the details of tasks and interfaces, and finally supplementing the detail codes in the scene.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210859360.1A CN117492723A (en) | 2022-07-21 | 2022-07-21 | Automatic industrial software code generation method based on data and behavior model |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210859360.1A CN117492723A (en) | 2022-07-21 | 2022-07-21 | Automatic industrial software code generation method based on data and behavior model |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN117492723A true CN117492723A (en) | 2024-02-02 |
Family
ID=89669512
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202210859360.1A Pending CN117492723A (en) | 2022-07-21 | 2022-07-21 | Automatic industrial software code generation method based on data and behavior model |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN117492723A (en) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN117724683A (en) * | 2024-02-07 | 2024-03-19 | 深圳海云安网络安全技术有限公司 | Business logic coding frame generation method and system based on large language model |
-
2022
- 2022-07-21 CN CN202210859360.1A patent/CN117492723A/en active Pending
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN117724683A (en) * | 2024-02-07 | 2024-03-19 | 深圳海云安网络安全技术有限公司 | Business logic coding frame generation method and system based on large language model |
| CN117724683B (en) * | 2024-02-07 | 2024-04-26 | 深圳海云安网络安全技术有限公司 | Business logic coding frame generation method and system based on large language model |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| Gomaa | Software modeling and design: UML, use cases, patterns, and software architectures | |
| Mattsson | Object-oriented frameworks | |
| Wang et al. | An automatic model-to-model mapping and transformation methodology to serve model-based systems engineering | |
| Islamovna | Situation-oriented databases: document management on the base of embedded dynamic model | |
| JP2011512592A (en) | Methods and systems for incorporating service-oriented automation components at the manufacturing floor into a flexible IT corporate architecture | |
| US20030131339A1 (en) | Methods and apparatus for batch program implementation | |
| CN117492723A (en) | Automatic industrial software code generation method based on data and behavior model | |
| Redding et al. | Transforming object-oriented models to process-oriented models | |
| Ma et al. | Bpel fragments for modularized reuse in modeling bpel processes | |
| Sunitha et al. | Object constraint language for code generation from activity models | |
| Weder et al. | MODULO: modeling, transformation, and deployment of quantum workflows | |
| CN116756338A (en) | AR assembly guidance-oriented process knowledge graph construction method and system | |
| Bocciarelli et al. | Automated development of web-based modeling services for MSaaS platforms. | |
| BOUSETTA et al. | Generating operations specification from domain class diagram using transition state diagram | |
| Autili et al. | On the Model-driven Synthesis of Adaptable Choreographies. | |
| Insaurralde et al. | System requirements in industrial automation | |
| US7437740B1 (en) | Generation of Java language application programming interface for an object-oriented data store | |
| Lüders | Use of component-based software architectures in industrial control systems | |
| Mihaela et al. | Automation of the Software Development Process from ReLEL Using the Praxeme Approach | |
| Mani | A configuration-based domain-specific rule generation framework for process model customization | |
| CN116909544A (en) | Automatic code generation method based on SysML model | |
| Nikiel | Automating software development for distributed control systems with the OPC UA standard | |
| Yuan et al. | Architecture-based Web service composition framework and strategy | |
| sohail Khan et al. | An intuitive Architecture for DIY IoT Application Composition as Business Process Model | |
| Rintamäki | Identifying Requirements in Microservice Architectural Systems |
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 |