CN114253547A

CN114253547A - Frame generation method and device, storage medium and electronic device

Info

Publication number: CN114253547A
Application number: CN202111401058.3A
Authority: CN
Inventors: 王振广
Original assignee: Qingdao Haier Technology Co Ltd; Haier Smart Home Co Ltd
Current assignee: Qingdao Haier Technology Co Ltd; Haier Smart Home Co Ltd
Priority date: 2021-11-19
Filing date: 2021-11-19
Publication date: 2022-03-29

Abstract

The embodiment of the invention provides a frame generation method, a frame generation device, a storage medium and an electronic device, wherein the method comprises the following steps: receiving a frame generation instruction for instructing generation of a target frame, wherein the frame generation instruction is an instruction input through a target interface; determining a frame template corresponding to the frame type from a frame library based on the frame type included in the frame generation instruction; determining a target code corresponding to a target frame based on parameter information included in the frame generation instruction; an object frame is generated based on the object code and the frame template. By the method and the device, the problems of low frame generation efficiency and high cost in the related technology are solved, the frame generation efficiency is improved, and the cost is reduced.

Description

Frame generation method and device, storage medium and electronic device

Technical Field

The embodiment of the invention relates to the field of communication, in particular to a method and a device for generating a framework, a storage medium and an electronic device.

Background

In the related technology, the development frames of all projects are not uniform, the versions of the used technical frames are not uniform, the problems of backward technology and difficult technical upgrading exist, the compatibility of different development frames needs to be considered in each new technical upgrading, and the upgrading cost is extremely high.

Therefore, the related art has the problems of low frame generation efficiency and high cost.

In view of the above problems in the related art, no effective solution has been proposed.

Disclosure of Invention

The embodiment of the invention provides a frame generation method and device, a storage medium and an electronic device, which are used for at least solving the problems of low frame generation efficiency and high cost in the related technology.

According to an embodiment of the present invention, there is provided a method for generating a framework, including: receiving a frame generation instruction for instructing generation of a target frame, wherein the frame generation instruction is an instruction input through a target interface; determining a frame template corresponding to the frame type from a frame library based on the frame type included in the frame generation instruction; determining an object code corresponding to the object frame based on parameter information included in the frame generation instruction; generating the target frame based on the target code and the frame template.

According to another embodiment of the present invention, there is provided a frame generation apparatus including: the system comprises a receiving module, a processing module and a display module, wherein the receiving module is used for receiving a frame generation instruction for indicating generation of a target frame, and the frame generation instruction is an instruction input through a target interface; a first determining module, configured to determine, from a frame library, a frame template corresponding to a frame type based on the frame type included in the frame generation instruction; a second determining module, configured to determine, based on parameter information included in the frame generation instruction, an object code corresponding to the object frame; a generating module for generating the target frame based on the target code and the frame template.

According to yet another embodiment of the invention, there is also provided a computer-readable storage medium having a computer program stored therein, wherein the computer program, when executed by a processor, implements the steps of the method as set forth in any of the above.

According to yet another embodiment of the present invention, there is also provided an electronic device, including a memory in which a computer program is stored and a processor configured to execute the computer program to perform the steps in any of the above method embodiments.

According to the method and the device, when a frame generation instruction for indicating generation of the target frame is received, a frame module corresponding to the frame type is determined from a frame library according to the frame type included in the frame generation instruction, an object code corresponding to the target frame is determined according to parameter information included in the frame instruction, and the target frame is generated according to the object code and the frame template. Because the target frame can be generated according to the input frame type and the parameter information without repeatedly developing the frame, the problems of low frame generation efficiency and high cost in the related technology can be solved, the frame generation efficiency is improved, and the cost is reduced.

Drawings

FIG. 1 is a diagram of a related art DDD architecture;

fig. 2 is a block diagram of a hardware configuration of a mobile terminal of a method for generating a framework according to an embodiment of the present invention;

FIG. 3 is a flow diagram of a method of generating a framework according to an embodiment of the invention;

FIG. 4 is a flow diagram of a method for generating a framework in accordance with a specific embodiment of the present invention;

FIG. 5 is a schematic diagram of an apparatus for generating a frame according to an embodiment of the present invention;

FIG. 6 is a schematic structural diagram of a hexagonal architecture in the related art;

FIG. 7 is a schematic diagram of a web interface service, domain services hierarchical architecture, according to an illustrative embodiment of the present invention;

FIG. 8 is a domain services web project layered architecture diagram in accordance with an illustrative embodiment of the present invention;

FIG. 9 is a relational diagram of each layer of components in the architecture in accordance with an illustrative embodiment of the present invention;

FIG. 10 is a partitioning of an engineering module of a framework into code structure diagrams in accordance with an exemplary embodiment of the present invention;

FIG. 11 is a diagram of an adaptation layer code structure according to an exemplary embodiment of the present invention;

FIG. 12 is a data transfer object class diagram in accordance with an exemplary embodiment of the present invention;

FIG. 13 is a client module code structure diagram in accordance with an exemplary embodiment of the present invention;

FIG. 14 is an application layer code structure diagram in accordance with an exemplary embodiment of the present invention;

FIG. 15 is a domain layer code structure diagram in accordance with an illustrative embodiment of the present invention;

FIG. 16 is a base layer code structure diagram in accordance with an exemplary embodiment of the present invention;

FIG. 17 is a flowchart of generating code according to an exemplary embodiment of the present invention;

fig. 18 is a block diagram of a structure of a frame generation apparatus according to an embodiment of the present invention.

Detailed Description

Hereinafter, embodiments of the present invention will be described in detail with reference to the accompanying drawings in conjunction with the embodiments.

It should be noted that the terms "first," "second," and the like in the description and claims of the present invention and in the drawings described above are used for distinguishing between similar elements and not necessarily for describing a particular sequential or chronological order.

The Maven ArchimeType is a Maven project template tool kit and supports the construction of a project template-mvn arch type: create-from-project in a command mode. However, the Maven arch type project template toolkit supports custom fixed templates, but does not support autonomous selection of dynamic add-drop features.

The Mybatis Generator \ Mybatis-plus Generator code generation tool can quickly generate database access codes and support custom templates for generating codes. However, the code models generated by the Mybatis Generator and the Mybatis plus Generator are traditional MVC three-layer architectures, the development mode focuses on process thinking, and the design idea of DDD and the domain-oriented microservice code model are not fused.

Ddd (domain drive design), i.e. domain drive design, the core concept is divide-and-conquer, abstraction and knowledge. The application layer comprises a display layer, an application layer, a field layer and an infrastructure layer. Referring to fig. 1, a schematic diagram of a DDD architecture is shown, as shown in fig. 1, the DDD includes:

a presentation layer: responsible for presenting information to the user and interpreting user commands. In more detail, the following are: requesting an application layer to acquire data required to be displayed by a user; sending a command to the application layer asks it to execute a certain user command.

An application layer: a very thin layer that defines all the tasks that the software is to perform. And providing various application functions (including query or command) for the presentation layer, and completing various business logics for the internal calling domain layer (domain object or domain service), wherein the application layer does not contain the business logics.

Field layer: the system is responsible for expressing business concepts, business state information and business rules, and a domain model is positioned at the layer and is the core of business software.

Infrastructure layer: the layer provides general technical capability for other layers; providing inter-layer communication; implementing a persistence mechanism for the domain layer; in summary, the infrastructure layer may support the technical requirements of other layers through the architecture and framework.

The domain layer comprises aggregation and domain layer services, and the aggregation comprises entities and value objects.

An Entity (Entity) is a domain concept that requires unique identification in the domain, i.e., a domain object. The domain objects include: attributes, behaviors, states. Instead of defining too many attributes or behaviors to an entity, an association should be found, some other entity or value object discovered, and the attributes or behaviors transferred to other associated entities or value objects.

Value Object (Value Object): basic Object types, String, Integer, Double, Boolean, Object, Collection.

Domain Service (Domain Service): some concepts in the field are less suitable for modeling as objects, e.g. some operations, actions. These operations or actions often involve multiple domain objects and coordination of these domain objects is required to accomplish the operation or action together. If any one object is forced to assign the operation duties, the assigned object bears some duties which are not supposed to bear, so that the duties of the object are not clearly and confusingly affected. General domain objects are stateful and behavioral, while domain services are stateless and behavioral only. The domain service is stateless, and the meaning of the domain service is that the domain objects are coordinated to complete a certain operation.

The functions are as follows: and the domain logic is prevented from being leaked to an application layer. Like the Faade mode (facade mode) provides a straightforward but well-defined interface by invoking domain services.

Polymeric and polymeric roots (Aggregate Root): aggregation is a domain schema used to define domain object ownership and boundaries, helping to simplify the relationships between model objects.

In the DDD architecture concept, only one application layered architecture design guidance concept is defined, differential design aiming at application engineering of different functions is lacked, and a detailed code model and a specific development assembly are proposed in combination with other design modes and architecture concepts.

In view of the above problems in the related art, the following embodiments are proposed:

the method embodiments provided in the embodiments of the present application may be executed in a mobile terminal, a computer terminal, or a similar computing device. Taking the example of the method running on the mobile terminal, fig. 2 is a hardware structure block diagram of the mobile terminal of the method for generating a framework according to the embodiment of the present invention. As shown in fig. 2, the mobile terminal may include one or more (only one shown in fig. 2) processors 102 (the processor 102 may include, but is not limited to, a processing device such as a microprocessor MCU or a programmable logic device FPGA) and a memory 104 for storing data, wherein the mobile terminal may further include a transmission device 106 for communication functions and an input-output device 108. It will be understood by those skilled in the art that the structure shown in fig. 2 is only an illustration, and does not limit the structure of the mobile terminal. For example, the mobile terminal may also include more or fewer components than shown in FIG. 2, or have a different configuration than shown in FIG. 2.

The memory 104 may be used to store computer programs, for example, software programs and modules of application software, such as computer programs corresponding to the generating method of the framework in the embodiment of the present invention, and the processor 102 executes various functional applications and data processing by running the computer programs stored in the memory 104, so as to implement the above-mentioned method. The memory 104 may include high speed random access memory, and may also include non-volatile memory, such as one or more magnetic storage devices, flash memory, or other non-volatile solid-state memory. In some examples, the memory 104 may further include memory located remotely from the processor 102, which may be connected to the mobile terminal over a network. Examples of such networks include, but are not limited to, the internet, intranets, local area networks, mobile communication networks, and combinations thereof.

The transmission device 106 is used to receive or transmit data via a network. Specific examples of the network described above may include a wireless network provided by a communication provider of the mobile terminal. In one example, the transmission device 106 includes a Network adapter (NIC) that can be connected to other Network devices through a base station to communicate with the internet. In one example, the transmission device 106 may be a Radio Frequency (RF) module, which is used to communicate with the internet in a wireless manner.

In this embodiment, a method for generating a frame is provided, and fig. 3 is a flowchart of a method for generating a frame according to an embodiment of the present invention, as shown in fig. 3, the flowchart includes the following steps:

step S302, receiving a frame generation instruction for instructing generation of a target frame, wherein the frame generation instruction is an instruction input through a target interface;

step S304, determining a frame template corresponding to the frame type from a frame library based on the frame type included in the frame generation instruction;

step S306, determining a target code corresponding to the target frame based on the parameter information included in the frame generation instruction;

step S308, generating the target frame based on the target code and the frame template.

In the above embodiment, the target interface may be an interface of a visualization front end, and the user may input a frame generation instruction for generating the target frame through the target interface. The frame generation instructions may include information for the selected frame type and parameters. After the frame type and the parameter information are determined, an 'immediate construction' button in a target interface can be clicked to generate a frame generation instruction. The parameter information may include frame parameters determined according to the frame type, identification information of the frame, and the like. The visual front-end interface can be a WEB interface, a client interface and the like.

In the above embodiment, the frame module corresponding to the frame type may be determined from the frame library according to the frame type in the frame generation instruction. The frame template in the frame library can be a predetermined frame module, and different frame types can correspond to different templates. The frame type may include a DDD type, an MVC type, and the like, and the frame module may be a DDD type template, an MVC type template, and the like.

In the above embodiment, the parameter information in the frame generation instruction may be converted into the object code, and the object code is filled into the corresponding position in the frame template, so as to generate the object frame,

optionally, the main body of the above steps may be a background processor or other devices with similar processing capabilities, and may also be a machine integrated with at least a data processing device, where the data processing device may include a terminal such as a computer, a mobile phone, and the like, but is not limited thereto.

In an exemplary embodiment, determining the object code corresponding to the target frame based on the parameter information included in the frame generation instruction includes: generating an identification code of the target frame based on identification information which is included in the parameter information and used for representing the target frame; determining component codes of components required for generating the target frame based on configuration information included in the parameter information; determining the identification code and the component code as the object code. In this embodiment, the identification information included in the parameter information may include an item type, an item group, an item name, a service module name, an item version number, and the like of the target framework. The business module name may be the name of the function implemented when the target framework is applied. The configuration information included in the parameter information may be information of a component configured for the target framework.

In the above embodiment, after the identification information and the parameter information are determined, the identification code of the target frame may be generated according to the identification information, and the component code may be generated according to the configuration information. That is, the identification information and the configuration information may be converted into codes, and the identification codes and the component codes may be determined as object codes corresponding to the object framework.

In one exemplary embodiment, generating the target frame based on the target code and the frame template comprises: determining corresponding positions of various codes included in the target codes in the frame template; adding the codes to the corresponding positions in the frame template respectively to obtain an updated frame module; and determining the updated frame template as the target frame. In this embodiment, configuration information required for project construction may be acquired, a corresponding framework component configuration instruction may be generated according to each configuration information, and a pre-generated related code of each framework component may be added to an established development framework template according to the framework component configuration instruction, so as to obtain a development framework required by a user.

In an exemplary embodiment, after generating the target frame based on the target code and the frame template, the method further comprises at least one of: uploading the target frame based on an uploading instruction; and downloading the target frame based on the downloading instruction. In this embodiment, after the target frame is generated, the target frame may be uploaded or downloaded. For example, the target frame is uploaded based on the uploading instruction, or the target frame is downloaded to the local according to the downloading instruction.

In an exemplary embodiment, uploading the frame object code corresponding to the target frame based on the uploading instruction includes: determining account information used for uploading the target frame and a target space for storing the target frame based on the uploading instruction; and uploading the target frame to the target space through the account information. In this embodiment, a user may input a user name, a password, and project group name information of a code repository GitLab (i.e., a target space) through a target interface, after the user name, the password, and the project group name information are input, a "build immediately" button may be clicked, a project building action is manually triggered, after the project is created, a newly created project may be automatically created under an assigned group of the code repository through a code uploading component, and after the project is uploaded, an address of the code repository where the project is located is returned. The user can click a 'download' button through the target interface, and after receiving a download instruction, the generated project codes of the target frame can be packaged into a compressed package and automatically downloaded to a local computer of the user.

In an exemplary embodiment, before determining a frame template corresponding to the frame type from a frame library based on the frame type included in the frame generation instruction, the method further includes: determining whether identification information included in the frame generation instruction and used for representing the target frame is occupied; and executing a prompt operation under the condition that the identification information is occupied. In this embodiment, after the identification information is determined, the code repository is automatically accessed to check whether the project name is repeated, that is, whether the project name of the target frame in the identification information is occupied is determined, and in the case that the project name is occupied, a prompt operation is performed to remind the user to re-input the project name. After the project name inspection is passed, the package name package and the project coordinate information (groupId and artifactId) of the new project are automatically generated according to the unified development naming standard. And clicking an 'immediate construction' button, and manually triggering a project construction action to obtain a target frame. The problems that the naming standards of the projects are not uniform, the naming of the projects is not standard, and further the problems caused by repeated naming when different projects are issued are solved.

In one exemplary embodiment, a frame type input through the target interface is determined; displaying selectable components and optional components corresponding to the frame type on the target interface; determining a target selectable component included in the selectable components input through the target interface; determining parameter information input through the target interface; generating the framework generation instruction based on the mandatory component, the target optional component and the parameter information. In the embodiment, the user can select at least one frame component in the target interface, view optional components and mandatory components supported by the frame, and the user can autonomously select to increase or decrease the components in the optional components. The user may also select a type of item, select a group of items, through a target interface. And necessary items such as project names and business module names are input through the target interface. And the option such as item version number and the like can be input. The method can automatically check whether the project name is repeated in a code warehouse according to the information input by a user, and automatically generate a package name package and project coordinate information (groupId and artifactId) of a new project according to a uniform development naming standard after the project name check is passed. Clicking an 'immediate construction' button to manually trigger a project construction action. Because the frame type corresponds to the selectable component, the frame type is used for selecting the required component on the basis, namely deleting, modifying and checking functions can be added on the development basis, and the problem of low development efficiency is solved through simple and repeated coding work.

The following describes a method for generating a frame in accordance with an embodiment:

fig. 4 is a flowchart of a method for generating a framework according to an embodiment of the present invention, as shown in fig. 4, the method includes:

in step S402, the user selects a project building function on the web interaction page (corresponding to the target interface).

In step S404, the user inputs the required information.

Step S406, selecting a project frame, a project group and a project type, and inputting a project name, a module name and a service scene name.

Step S408, checking whether the input item name is occupied in the code repository.

In step S410, it is determined whether or not the item name is already present, and if the determination result is yes, step S412 is executed, and if the determination result is no, step S414 is executed.

Step S412, prompting the project name to repeat, please re-input.

Step S414, acquiring the user input information, and generating a project package name and project coordinate information.

In step S416, it is determined whether padding information is input, and if the determination result is yes, step S418 is executed, and if the determination result is no, step S422 is executed.

In step S418, the user inputs the filling information.

And step S420, item version number, Gitlab code warehouse account number, password and code group name.

In step S422, the user selects an optional function component (corresponding to the above-described optional component).

In step S424, the user clicks the immediate construction button.

In step S426, the back-end interface module obtains the user construction request (corresponding to the above-mentioned frame generation instruction).

In step S428, the project building module obtains information such as the selected frame type and the target name, the package name, the project coordinates, and the like.

And step S430, downloading the appointed frame module from the Maven private server warehouse, generating a new project code and storing the new project code in a local temporary directory of the server.

Step S432 is to acquire configuration information of each optional functional component, and generate a build instruction corresponding to each configuration information.

In step S434, each framework component configuration instruction is executed to delete the unneeded function component codes from the new project framework.

Step S436 determines whether the Gitlab account information is empty, and if the determination result is yes, step S438 is executed, and if the determination result is no, step S448 is executed.

Step S438, returns the project construction success information.

In step S440, the user clicks the download button.

In step S442, the back-end interface module obtains the user download request.

In step S444, the code download module packages the generated project codes into a compressed package, returns the file download stream, and deletes the project code file of the server.

Step S446, downloading the project file to the local.

And step S448, the code uploading module uploads the generated code to a specified warehouse according to the code warehouse account number, the password and the group name.

And step S450, cleaning the project code file stored by the server.

And step S452, returning to the uploading completion.

Fig. 5 is a schematic structural diagram of a frame generation apparatus according to an embodiment of the present invention, and as shown in fig. 5, the apparatus includes: the system comprises a web front-end module, a rear-end interface module, a project construction module, a code downloading module and a code uploading module.

The Web front-end module is a Web user interaction page and is responsible for interacting with users, and the development framework is conveniently generated through visual operation of the users.

The back-end interface module is used for receiving the request of the web front-end module, processing the user request, calling other modules to complete specific functions and returning a processing result.

And the project construction module is used for automatically matching corresponding project frame templates according to the selected frame types and generating new project codes according to information such as project names and the like. And generating respective functional component configuration commands according to the configuration information of the selectable functional components, and deleting functions of the newly generated project framework so as to meet the requirements of users.

The code downloading module is used for providing a code packaging and downloading function, packaging the generated project codes into a compression package and downloading the compression package to the local part of a user.

The code uploading module is used for automatically uploading the generated project codes to a code warehouse path appointed by a user according to the provided internal code warehouse account and password information, and the steps of manually uploading the project codes to the code warehouse by the user are reduced.

In the foregoing embodiments, the back-end micro-service project development framework may be quickly constructed through visualization operations. A user can autonomously select any project frame in a visualization operation page, and the frame comprises a mandatory functional component and an optional functional component. The necessary functional components can not be selected by self definition, and the optional functional components support autonomous increase and decrease. The method comprises the steps of checking required selectable functional components on a page, selecting a project type and a project group, inputting information such as a project name, a service module name, a service scene name and a version number, and automatically generating project coordinate information such as a package path, a Maven group id and a Maven artifactId according to a unified project naming specification. Clicking the immediate construction button, automatically generating project codes and downloading the project codes to the local in a compressed package form. Meanwhile, the method supports the input of a GitLab account number, a password and a group name, and the generated project can be automatically uploaded to a GitLab code warehouse.

The application of different functions corresponds to different project framework templates, the development framework template built in the system can be a domain-oriented micro-service framework code model based on DDD, and is realized by combining design ideas such as a DDD framework, a Clean framework, a hexagon framework, a Command and Query Responsibility Separation (CQRS) framework, a service-oriented framework, an event-driven framework, a service customization package and platform separation framework and the like. The design of transverse function layering and longitudinal field sub-packaging is adopted, a strict layering architecture is adopted, and a certain layer can only be coupled with a layer directly below the certain layer. The hexagonal architecture is also called a port and adapter mode, and is an architecture style with symmetry features proposed by Alistair Cockburn. In the architecture, the system interacts with the outside by means of an adapter, and the application service and the domain service are packaged in the system. The hexagonal structure is also a layered structure, and the structural schematic diagram of the hexagonal structure can be seen in fig. 6, as shown in fig. 6, the hexagonal structure is divided into three layers: port adapter, application layer and domain layer. And the port can be divided into an input port and an output port.

Input port: the method is used for exposing an API interface when the system provides service, receiving the input of an external client system, and converting the input of the client system into the input understood in the program. The access layer to which the system is external as a service provider can be regarded as an input port.

Output port: support is provided for the system to obtain external services, such as obtaining persistent state, persisting results, or issuing change notifications (e.g., domain events) for domain state. The interface (database, cache, message queue, RPC call) of the system, which is used as the service for the consumer to obtain the service, can be regarded as the input port.

An application layer: the work that the system can do is defined, a very thin layer. It does not process business logic and completes business logic by coordinating domain objects or domain services and outputs results through input ports. Transaction management can also be done at this level.

Field layer: the charge represents the concept, rule and state of the service, and belongs to the core of the service.

The invariance of the application layer and the domain layer can ensure that the core domain is not interfered by the outside, and the replaceability of the port can be conveniently butted with an unused external system.

In the foregoing embodiment, when the target frame is generated, the visualization degree is high, the operation is easy, the understanding is easy, and a new project frame, that is, the target frame, can be generated simply and conveniently. And technical statistics is developed, and upgrading and maintenance are facilitated. And multiple choices can be provided for different functional items, and the most suitable frame template is automatically recommended. The method has the advantages of optional functions, guarantee of consistent development framework versions and complete basic functions. The selectable functions are selected independently, different development scenes are adapted, unnecessary function dependence is reduced, and burden is reduced for the project.

In the foregoing embodiments, a horizontal functional hierarchical, vertical domain sub-packaging design may be adopted, and a strict hierarchical architecture is adopted, so that a layer can only be coupled with a layer directly below the layer. The framework module can be divided into a basic service project template, a field service Web project template and an interface service Web project template. And selecting and matching different development frameworks aiming at the applications with different functions. By adopting an object thinking mode, the whole team uses a group of general terms and definitions by using business to be oriented, and the business tracking is easier. The software design perfection is improved, codes are easy to read, the repetition is reduced, and the maintenance is easy. The model can be repeatedly used, so that repeated models are avoided, and the problems that codes are difficult to modify, test and read are solved. The maintainability and expansibility of the system are improved, the service complexity and the technical complexity are effectively isolated, and the domain model is used as a stable and cohesive core of the whole system, and is separated and unchanged.

The project frame template can be stored in a micro service frame library, and can be divided into a Dubbo basic service template, a Dubbo field service template, a web field service template and a web interface service template according to functions. The communication between the micro services in the system uses Dubbo protocol transmission, and the system provides an HTTP protocol interface for the outside. The transmission efficiency of the internal micro-service network is improved, the response delay caused by network resource limitation is reduced, and the response time of the whole request link is prolonged. The micro-service can provide the HTTP and the Dubbo protocol simultaneously, and meets the requirements of high efficiency, low delay and simple, standard and quick access of an internal access scene and an external access scene.

The Dubbo basic service template and the Dubbo domain service template can adopt a four-layer framework: the system comprises a client layer, an application service layer, a field layer and an infrastructure layer.

The Web interface service template may include an adaptation layer.

The Web domain service template can comprise an adaptation layer, a client layer, an application service layer, a domain layer and an infrastructure layer. The adaptation layer is associated with the client layer, the application layer realizes the client layer, the application layer is associated with the field layer, the infrastructure layer realizes the field layer, and the application layer depends on the infrastructure layer. The Web domain service can simultaneously provide the Dubbo protocol service and the HTTP protocol interface service to the outside.

The adaptation layer of the Web interface service has an association relation with the client layer of the Dubbo field service, data transmission is carried out through a network based on a Dubbo service protocol, the Web interface service carries out protocol conversion and service encapsulation on the Dubbo field service through the adaptation layer, and multi-terminal function adaptation of a Web terminal, a mobile terminal, an IoT terminal and the like is achieved. The application layer of the Dubbo field service realizes a client layer, an application layer is related to a field layer, an infrastructure layer realizes the field layer, and the application layer depends on the infrastructure layer. The schematic diagram of the web interface service and domain service hierarchical architecture can be seen in fig. 7, the schematic diagram of the domain service web project hierarchical architecture can be seen in fig. 8, the relationship diagram of each layer of components in the architecture can be seen in fig. 9, and the structural diagram of the engineering module division code structure of the framework can be seen in fig. 10.

Compared with a DDD four-layer framework, the framework of the Web field service template divides the function of a presentation layer into an adaptation layer and a client layer, the adaptation layer processes HTTP (hyper text transport protocol) requests sent by users and assembles data, and the client layer is responsible for defining a data transmission format and an application layer Facade interface.

The adaptation layer included in the framework of the template can provide service adaptation for the front end and provide resource adaptation for the resource layer. This layer aggregates interface adaptation related functions. Responsible for routing and adaptation of the front-end exposure (web, mobile, IoT), for legacy B/S systems, the adapter behaves as a controller in MVC. For the HTTP request, the layer is mainly used for processing a Restful request sent by a user and analyzing a configuration file input by the user; and the related client layer transmits the data to the Application layer in an internal engineering calling mode or transmits the data to the Application layers of other Dubbo services in a remote process calling mode.

The Web service, namely a Controller for processing page requests, exposes an Http interface, and most interface functions are required to be under a Web package.

mobile terminal service, which processes wireless terminal special function adaptation.

Iot service, which handles the specific function adaptation of IoT terminals.

The adaptation layer can be independently positioned in a web interface service project, remotely calls other Dubbo field service projects through network communication, can also be integrated in the web field service project, and converts a Dubbo service protocol into an HTTP protocol to provide web interface services. By converting and packaging the network protocol and the data protocol, various terminal devices are flexibly adapted, and a multi-service scene is adapted. The structure diagram of the adaptation layer code can be seen in fig. 11.

The client layer included in the framework of the template can store codes related to the interaction and data display of the client layer and the outside. The external application obtains the required data from the application service through the interface of the layer. The data assembly, data transmission format, and codes such as the Facade interface are all placed in this layer of directory.

For RPC protocol requests, this layer is mainly used to provide client calls to the SDK, including the Dubbo service interface API and the data transfer object DTO.

The application service interface API is a service interface API provided by the service, mainly an API of Dubbo RPC service and a RESTful request API.

And a data transmission object DTO, namely a DTO object provided by a service pair, wherein the object class inherits the DTO parent class. The method is divided into two types of client request object request and data object response, and the client request object code packet path request and the data object code packet path response.

Data object response refers to the object used to transmit the results returned by the service. The Response class inherits the parent DTO class, and is further subdivided into a SingleResponse (data format is generic T), a Multiresponse (data format is generic Collection < T >), and a Pageresponse (data format is generic Collection < T >), and simultaneously contains pageSize, pageIndex, and totalCount paging query parameters) according to different data structures of returned results.

The client request object request refers to a client object for receiving request parameters, and can be divided into Command and Query types according to a Command Query Responsibility Separation (CQRS) architecture mode. The Command class inherits a parent DTO class, the Query class inherits a parent Command class, and the PageQuery class inherits a Query class. When the code is developed, the Query class request parameter inherits a Query parent class, the paging Query class request parameter inherits a PageQuery parent class, and the non-Query class request parameter inherits a Command parent class.

The client layer can package the Dubbo service API and request parameters and return results, so that the development cost of other services when calling the services is reduced, the development code amount is reduced, and the service calling specification is defined. The data transmission object class diagram can be referred to in fig. 12, and the client module code structure diagram can be referred to in fig. 13.

The application layer in the framework of the template may be responsible for obtaining inputs, assembling contexts, parameter checking, requesting authentication, processing Request requests, transaction control, and the like. Service combination and arrangement are realized, and the requirement of rapid change of the business process is met. This layer aggregates application service and event related functionality. And the application layer calls the domain layer to perform service processing. Different layers in the engineering are isolated, and an application layer only allows access to a domain layer and not allows access to a basic implementation layer. The structure of the application layer code structure can be seen in fig. 14.

Application service: and the concrete implementation of the application service realizes a service api interface. And providing business related services and task scheduling services. The specific service logic implementation adopts a command mode and is realized by a corresponding executor. The service class only makes simple command calls.

Command executor: the request type is divided into a common command and a query according to the request type, and a responsibility separation architecture (CQRS) is adopted to be classified into a CmdExe class and a QryExe class and respectively process common command operation and query class operation.

Subscription event handler subscribe: and the message event subscription processing module subscribes the message events in the message queue and calls the lower-layer module to perform service processing.

The timed task processor jobi: and processing the timing tasks, and uniformly scheduling by a distributed task scheduling center.

The object converter converts the DTO and the Model object into each other.

The parameter checker validator checks whether the DTO request parameter and the request parameter are not empty or other validity checks.

The Domain Layer (Domain Layer) in the framework of the template can realize the core business logic of the Domain, the Domain Layer aggregates Domain objects such as aggregation, aggregation roots, entities, value objects, Domain services, events and the like of the Domain Model and business capabilities formed by combination of the Domain objects, and business entity and business logic calculation is provided for the App Layer through a Domain Service method and a Domain object (Domain Model) method. The field is the core of the application and does not depend on any other layer in the project; and the second square base Client does not depend on any other project. The schematic diagram of the domain layer code structure can be seen in fig. 15.

Domain Model (Domain Model): the domain model object (entity and value object) comprises data and basic behavior capability, and the internal attribute definition in the domain provides basic getter, setter, attribute judgment and simple business state judgment. The domain model objects are stateful objects, are objects with instance variables (data members), can store data, are non-thread-safe, and require manual creation of objects (instantiation).

Domain ability (ability): the Domain Service system is composed of a Domain object (Domain Model), a Domain Rule (Domain Rule) and a Domain Service (Domain Service). Domain capabilities are stateless objects, objects without instance variables. Data cannot be saved, the class is unchanged, and the thread is safe. The object life cycle is managed by a Spring container.

Domain object (Domain Model): and basic getter, setter, constractor and attribute judgment capability are provided. If the action of a domain capability is a verb and belongs to an entity or value object, the capability is provided by the corresponding domain Model.

Domain Service (Domain Service) all business logic within the Domain is implemented in the Domain Service. And the service logic of the field is realized through the sub-field aggregation, and various complex field actions, operations and behavior capabilities are provided.

Domain Rule (Domain Rule): the method is used for business rule checking and multi-business scene rule checking.

Domain Repository (Domain Repository): decoupling sharers, decoupling business logic and technical implementation details, infrastructure layer capability abstraction definitions in the field, such as RPC capability abstraction of persistent layer databases, search engines, file systems, distributed services.

The Infrastructure Layer (Infrastructure Layer) in the above-described framework may be responsible for the handling of technical detail issues, such as CRUD of databases, search engines, file systems, RPC of distributed services, etc. In addition, the field of preservation also falls here, and external dependence requires a transposition process by a repositor to be used by the above App layer and Domain layer. The structure of the base layer code structure can be seen in fig. 16.

The field warehouse realizes the RepositoryImpl and the anticorrosive coating. Integrating database, Dubbo RPC, Cache, search engine search, API gateway httpparent, event message bus, third party tool util, basic service, other basic components, etc.

Database persistent layer operation, which is divided into: the entity database table mockup and the mapper database map.

And (4) caching cache, namely, implementing caching operation.

Configuring config: and configuring information.

Search engine search: a search engine implementation.

And the API gateway client calls the remote Http interface to realize and calls other basic services.

The message issuing event is a message processing class and specifically realizes the issuing function of the message.

The framework of the template can also comprise a starting layer which comprises an application starting class, a configuration file and a unit test code and realizes the separation of the application code, the configuration and the test code. The code function is clear, the code reading difficulty is reduced, the test and the service code are separated, the coupling degree of the service code and the test code is reduced, the software testability is improved, and the code complexity is reduced.

The code reusability can be improved by constructing the framework template, the coupling degree is reduced, the maintainability is improved, the readability is improved, the testability is improved, the code idleness rate is reduced, the development efficiency is improved along with the improvement of the service complexity, the multi-person collaborative development can be realized, the development speed is improved, the quick iteration of a software system is facilitated following the service.

In the related technology, because the project architecture is not uniform, the project architecture is a process-oriented micro-service architecture, the service logic and the bottom technical code are mixed together, the code readability is low, the project maintenance cost is high, the expandability is poor, and the quick iteration of the service requirement cannot be adapted sufficiently. Code redundancy, low code reuse rate and difficult unit test. When a new project is constructed, the traditional manual construction mostly adopts copying of an existing project code and then manual deletion of a service code, or the construction is started step by step from scratch, which is time-consuming and labor-consuming and has high frame bug rate.

Therefore, after the target frame is determined, the codes corresponding to the target frame can be sorted according to the code template, so that the readability of the codes is improved, and the maintenance cost and the error rate of the frame codes are reduced.

The DDD code model-based code generator component can be matched in the target framework and integrated into the framework in the form of an external dependency package, and a user configures necessary configuration information in a property file, such as: database connection information, database user names, database passwords, database table names, sub-field names, class file name prefixes, authors and sub-field function descriptions, and optionally configured configuration information is selected and configured autonomously, for example: and whether a database operation function code is generated or not and whether a control class Controller function code is generated or not are judged, then a Main function Main method of a code generation class is operated, and the required code is automatically generated. The generated code comprises functions of basic addition, deletion, modification, searching and the like, and comprises codes of a user interface layer, a client layer, an application layer, a field layer, an infrastructure layer and the like. The code model types supporting autonomous selection generation are divided into a DDD (distributed data description) hierarchical architecture code model and an MVC (model view controller) architecture code model.

The code Generator component can use a Freemarker template engine to predefine a code template based on a Mybatis-plus Generator tool, automatically read properties attribute parameters configured by a user during running, select a code model template to be generated according to frame type parameters configured by the user, select a code file to be generated according to enabled function parameters configured by the user, and then replace a placeholder in the code template in a variable mode to generate a basic function code which meets the requirements of the user and meets the frame naming specification.

And if the database access function is started, analyzing the database table structure by using a Mybatis-Plus Generator according to the information such as the field name, the table name, the database connection and the like configured by the user, and generating a database function code conforming to the Mybatis frame model.

If the controller function is enabled, a web interface function code is generated.

Fig. 17 is a flowchart for generating a code, and as shown in fig. 17, the flowchart includes:

in step S1702, a DOMAGENERATOR-like Main method is run.

Step S1704, the generator and properties file configuration information under the ckasspath directory is read and loaded into the software memory.

Step S1706, the git account information parsing module generates a git account information parsing command.

Step S1708, determining the type of the operating system, and if the operating system is a windows system, executing step S1710, and if the operating system is a unix system, executing step S1712.

Step S1710, calling cmd program to execute git account information parsing command.

Step S1712, call the bash program to execute the git account information parsing command.

Step S1714, get git login account, set as file author.

Step S1716, setting database connection information: connection url, user name, password.

Step S1718, set the default code generation function of the disabled Mybatis-Plus Generator component.

Step S1720, setting custom variable information.

In step S1722, the code module type is determined to be generated, and step S1724 is executed if the determination result is the MVC architecture, and step S1726 is executed if the determination result is the DDD architecture.

Step S1724, setting the code generation file path and the package name to conform to the MVC architecture style.

Step S1726, setting the generated file path and the package name, and conforming to the DDD layered architecture style.

Step S1728, setting a custom code template path, and generating a code file output path configuration list.

In step S1730, it is determined whether or not a database function code is generated, and if the determination result is yes, step S1732 is executed, and if the determination result is no, step S1734 is executed.

Step S1732, add a database function template path, and generate code file output path information to the configuration list.

In step S1734, it is determined whether or not the web interface function code is generated, and if the determination result is yes, step S1736 is executed, and if the determination result is no, step S1738 is executed.

Step S1736, add a web interface function template path, and generate code file output path information to the configuration list.

Step S1738, add code template paths of functions of the client layer, the application layer, the domain layer, and the infrastructure layer, and generate code file output path information to the configuration list.

In step S1740, the template engine is set to freemaker.

Step S1742, call the Mybatis-Plus Generator component to execute the method, and generate the code to the local disk.

In the above embodiment, each project frame includes a code generator module, and may generate a complete set of function codes of basic functions such as query, addition, modification, deletion, and the like based on a table structure of a database, support flexible configuration of a code generation function in a property attribute file manner, autonomously select whether to enable a database connection function or a control class Controller function, and generate a code that follows a DDD hierarchical architecture and a domain-oriented code model, thereby achieving low code development and improving development efficiency. In addition, different development frames are matched with the code generator, basic addition, deletion, modification and check function codes can be quickly generated, the development code amount is reduced, the development mode is standardized, and the learning threshold of developers for practicing DDD is lowered.

In the embodiment, a new project is generated through the project construction system, a unified development framework is formed, the development framework template is updated irregularly, the technical advancement is kept, the technical standard is unified, the system technology is convenient to upgrade, and the cost of upgrading the basic functions of the system is reduced. A user flexibly selects different types of development frames on an interactive page, a new project framework is generated by one key, downloading to the local and synchronous uploading to a code warehouse are supported, time and labor are saved, and new project construction is made in 1 minute. The system built-in development framework is verified through multiple tests, the basic function is complete, the bug rate of the framework is low, and the framework is matched with development document guidance to ensure that developers can use the framework when opening the box. The traditional development thinking mode is changed, and the process thinking is converted into the object thinking. The domain-oriented micro-service architecture is adopted, the DDD design idea is popularized, and a code generator component which accords with a DDD code model is matched, so that development thinking mode conversion of developers is facilitated, and the learning threshold is lowered. A code generator component is arranged in the frame, based on a DDD code model, through simple database connection configuration and field name configuration, functional codes are added, deleted, changed and checked on the basis of one-key generation, simple and repeated coding work is reduced, and development efficiency is greatly improved. A user selects a project type on an interactive page, inputs a project name, a project group name, a service module name and a service scene name, the system automatically checks whether the project name is repeated in a code warehouse, and automatically generates a project package name and project coordinate information according to a unified naming rule, so that project issuing conflict caused by the fact that the project name is not standard is avoided.

Through the above description of the embodiments, those skilled in the art can clearly understand that the method according to the above embodiments can be implemented by software plus a necessary general hardware platform, and certainly can also be implemented by hardware, but the former is a better implementation mode in many cases. Based on such understanding, the technical solutions of the present invention may be embodied in the form of a software product, which is stored in a storage medium (e.g., ROM/RAM, magnetic disk, optical disk) and includes instructions for enabling a terminal device (e.g., a mobile phone, a computer, a server, or a network device) to execute the method according to the embodiments of the present invention.

In this embodiment, a frame generating device is further provided, and the device is used to implement the foregoing embodiments and preferred embodiments, and details of which have been already described are omitted. As used below, the term "module" may be a combination of software and/or hardware that implements a predetermined function. Although the means described in the embodiments below are preferably implemented in software, an implementation in hardware, or a combination of software and hardware is also possible and contemplated.

Fig. 18 is a block diagram of a structure of a frame generation apparatus according to an embodiment of the present invention, and as shown in fig. 18, the apparatus includes:

a receiving module 1802, configured to receive a frame generation instruction for instructing generation of a target frame, where the frame generation instruction is an instruction input through a target interface;

a first determining module 1804, configured to determine, from a frame library, a frame template corresponding to a frame type based on the frame type included in the frame generation instruction;

a second determining module 1806, configured to determine, based on parameter information included in the frame generation instruction, an object code corresponding to the target frame;

a generating module 1808, configured to generate the target frame based on the target code and the frame template.

The receiving module corresponds to the web front-end module, the first determining module corresponds to the rear-end interface module, and the second determining module and the generating module correspond to the project building module.

In an exemplary embodiment, the second determining module 1806 may determine the object code corresponding to the target frame based on the parameter information included in the frame generation instruction by: generating an identification code of the target frame based on identification information which is included in the parameter information and used for representing the target frame; determining component codes of components required for generating the target frame based on configuration information included in the parameter information; determining the identification code and the component code as the object code.

In an exemplary embodiment, the generating module 1808 may implement generating the target frame based on the target code and the frame template by: determining corresponding positions of various codes included in the target codes in the frame template; adding the codes to the corresponding positions in the frame template respectively to obtain an updated frame module; and determining the updated frame template as the target frame.

In an example embodiment, the apparatus may be configured to upload the target frame based on an upload instruction after generating the target frame based on the target code and the frame template; and downloading the target frame based on the downloading instruction.

In an exemplary embodiment, the apparatus may enable uploading of the frame object code corresponding to the target frame based on the upload instruction by: determining account information used for uploading the target frame and a target space for storing the target frame based on the uploading instruction; and uploading the target frame to the target space through the account information.

In an exemplary embodiment, the apparatus may be further configured to determine whether identification information included in the frame generation instruction and used for representing the target frame is occupied before determining a frame template corresponding to the frame type from a frame library based on the frame type included in the frame generation instruction; and executing a prompt operation under the condition that the identification information is occupied.

In an exemplary embodiment, the apparatus may enable generating the framework generation instruction by: determining a frame type input through the target interface; displaying selectable components and optional components corresponding to the frame type on the target interface; determining a target selectable component included in the selectable components input through the target interface; determining parameter information input through the target interface; generating the framework generation instruction based on the mandatory component, the target optional component and the parameter information.

It should be noted that, the above modules may be implemented by software or hardware, and for the latter, the following may be implemented, but not limited to: the modules are all positioned in the same processor; alternatively, the modules are respectively located in different processors in any combination.

Embodiments of the present invention also provide a computer-readable storage medium having a computer program stored thereon, wherein the computer program, when executed by a processor, implements the steps of the method as set forth in any of the above.

In an exemplary embodiment, the computer-readable storage medium may include, but is not limited to: various media capable of storing computer programs, such as a usb disk, a Read-Only Memory (ROM), a Random Access Memory (RAM), a removable hard disk, a magnetic disk, or an optical disk.

Embodiments of the present invention also provide an electronic device comprising a memory having a computer program stored therein and a processor arranged to run the computer program to perform the steps of any of the above method embodiments.

In an exemplary embodiment, the electronic apparatus may further include a transmission device and an input/output device, wherein the transmission device is connected to the processor, and the input/output device is connected to the processor.

For specific examples in this embodiment, reference may be made to the examples described in the above embodiments and exemplary embodiments, and details of this embodiment are not repeated herein.

It will be apparent to those skilled in the art that the various modules or steps of the invention described above may be implemented using a general purpose computing device, they may be centralized on a single computing device or distributed across a network of computing devices, and they may be implemented using program code executable by the computing devices, such that they may be stored in a memory device and executed by the computing device, and in some cases, the steps shown or described may be performed in an order different than that described herein, or they may be separately fabricated into various integrated circuit modules, or multiple ones of them may be fabricated into a single integrated circuit module. Thus, the present invention is not limited to any specific combination of hardware and software.

The above description is only a preferred embodiment of the present invention and is not intended to limit the present invention, and various modifications and changes may be made by those skilled in the art. Any modification, equivalent replacement, or improvement made within the principle of the present invention should be included in the protection scope of the present invention.

Claims

1. A method for generating a framework, comprising:

receiving a frame generation instruction for instructing generation of a target frame, wherein the frame generation instruction is an instruction input through a target interface;

determining a frame template corresponding to the frame type from a frame library based on the frame type included in the frame generation instruction;

determining an object code corresponding to the object frame based on parameter information included in the frame generation instruction;

generating the target frame based on the target code and the frame template.

2. The method of claim 1, wherein determining the object code corresponding to the object frame based on the parameter information included in the frame generation instruction comprises:

generating an identification code of the target frame based on identification information which is included in the parameter information and used for representing the target frame;

determining component codes of components required for generating the target frame based on configuration information included in the parameter information;

determining the identification code and the component code as the object code.

3. The method of claim 1, wherein generating the target frame based on the target code and the frame template comprises:

determining corresponding positions of various codes included in the target codes in the frame template;

adding the codes to the corresponding positions in the frame template respectively to obtain an updated frame module;

and determining the updated frame template as the target frame.

4. The method of claim 1, wherein after generating the target frame based on the target code and the frame template, the method further comprises at least one of:

uploading the target frame based on an uploading instruction;

and downloading the target frame based on the downloading instruction.

5. The method of claim 4, wherein uploading the frame object code corresponding to the target frame based on the upload instruction comprises:

determining account information used for uploading the target frame and a target space for storing the target frame based on the uploading instruction;

and uploading the target frame to the target space through the account information.

6. The method of claim 1, wherein before determining a frame template corresponding to the frame type from a frame library based on the frame type included in the frame generation instruction, the method further comprises:

determining whether identification information included in the frame generation instruction and used for representing the target frame is occupied;

and executing a prompt operation under the condition that the identification information is occupied.

7. The method of claim 1, wherein the framework generation instructions are generated by:

determining a frame type input through the target interface;

displaying selectable components and optional components corresponding to the frame type on the target interface;

determining a target selectable component included in the selectable components input through the target interface;

determining parameter information input through the target interface;

generating the framework generation instruction based on the mandatory component, the target optional component and the parameter information.

8. An apparatus for generating a frame, comprising:

the system comprises a receiving module, a processing module and a display module, wherein the receiving module is used for receiving a frame generation instruction for indicating generation of a target frame, and the frame generation instruction is an instruction input through a target interface;

a first determining module, configured to determine, from a frame library, a frame template corresponding to a frame type based on the frame type included in the frame generation instruction;

a second determining module, configured to determine, based on parameter information included in the frame generation instruction, an object code corresponding to the object frame;

a generating module for generating the target frame based on the target code and the frame template.

9. A computer-readable storage medium, in which a computer program is stored, which computer program, when being executed by a processor, carries out the steps of the method according to any one of claims 1 to 7.

10. An electronic device comprising a memory and a processor, wherein the memory has stored therein a computer program, and wherein the processor is arranged to execute the computer program to perform the method of any of claims 1 to 7.