CN115934046A

CN115934046A - Application program development method, device, equipment and storage medium

Info

Publication number: CN115934046A
Application number: CN202211230523.6A
Authority: CN
Inventors: 丁延强
Original assignee: Beijing Fangduoduo Information Technology Co ltd
Current assignee: Beijing Fangduoduo Information Technology Co ltd
Priority date: 2022-10-08
Filing date: 2022-10-08
Publication date: 2023-04-07

Abstract

The embodiment of the application provides an application program development method, an application program development device, application program development equipment and a storage medium. In the embodiment of the application, the development environments of different program objects run on the server, the development environments of different program objects need different component libraries, in order to avoid the mutual influence of the development environments of different program objects, each program object corresponds to a subprocess, different subprocesses are allocated with independent running resources, the development environments of different program objects run on the independent running resources, and when the client develops a program object, the client develops based on the development environment corresponding to the program object on the server, so that the development environments for developing different program objects run without interference.

Description

Application program development method, device, equipment and storage medium

Technical Field

The present application relates to the field of data processing technologies, and in particular, to a method, an apparatus, a device, and a storage medium for developing an application program.

Background

In general, when an application program is developed on a local computer, a developer needs to spend a lot of time and manually writing codes, which is time-consuming, labor-consuming and inefficient.

The low-code development platform can encapsulate and visualize some basic functional modules, developers can build basic functions of the application program in an operation mode of dragging and pulling, and the developers can concentrate on parts needing manual coding, so that the development efficiency is improved. Therefore, the application program can be developed on line based on the low-code development platform, but how to develop a plurality of application programs on line simultaneously and the operating environments of the plurality of application programs are not interfered with each other is a problem to be solved urgently.

Disclosure of Invention

Aspects of the present application provide an application development method, apparatus, device and storage medium, so as to implement that operating environments for developing multiple applications do not interfere with each other.

The embodiment of the application provides an application program development method, which is suitable for a server and comprises the following steps: receiving a program development request aiming at a target program object sent by a target client, wherein the target program object is an application program or at least one functional module in the application program; if the development environment of the target program object does not exist on the server, acquiring a development environment description file corresponding to a component library required by the target program object; creating a target subprocess corresponding to the target program object, and allocating independent running resources for the target subprocess, wherein the server comprises at least one target subprocess corresponding to at least one target program object, and different running resources are allocated to target subprocesses corresponding to different target program objects; controlling the target subprocess to create and run a development environment of the target program object according to a development environment description file corresponding to a component library required by the corresponding target program object; and providing the page data corresponding to the development environment of the target program object to the target client so that the target client can display the program development page corresponding to the page data.

An embodiment of the present application further provides an application development apparatus, including: the device comprises a receiving module, an obtaining module, a creating module, a distributing module, a control module and a providing module; the receiving module is used for receiving a program development request aiming at a target program object sent by a target client, wherein the target program object is an application program or at least one functional module in the application program; the acquisition module is used for acquiring a development environment description file corresponding to a component library required by the target program object if the development environment of the target program object does not exist on the application program development device; the creating module is used for creating a target subprocess corresponding to the target program object and allocating independent running resources to the target subprocess, wherein the application program developing device comprises at least one target subprocess corresponding to at least one target program object, and different running resources are allocated to target subprocesses corresponding to different target program objects; the control module is used for controlling the target subprocess to create and operate a development environment of the target program object according to a development environment description file corresponding to the component library required by the corresponding target program object; the providing module is used for providing the target client with the page data corresponding to the development environment of the target program object so that the target client can display the program development page corresponding to the page data.

An embodiment of the present application further provides an application development device, including: a memory and a processor; a memory for storing a computer program; and the processor is coupled with the memory and used for executing the computer program so as to realize the steps in the application program development method provided by the embodiment of the application program.

Embodiments of the present application further provide a computer-readable storage medium storing a computer program, which, when executed by a processor, causes the processor to implement the steps in the application program development method provided in the embodiments of the present application.

In the embodiment of the application, the development environments of different program objects run on the server, the development environments of different program objects need different component libraries, in order to avoid the mutual influence of the development environments of different program objects, each program object corresponds to a subprocess, different subprocesses are allocated with independent running resources, the development environments of different program objects run on the independent running resources, and when a client develops a program object, the client develops the program object based on the development environment corresponding to the program object on the server, so that the operation of developing different program objects without mutual interference is realized.

Drawings

The accompanying drawings, which are included to provide a further understanding of the application and are incorporated in and constitute a part of this application, illustrate embodiment(s) of the application and together with the description serve to explain the application and not to limit the application. In the drawings:

fig. 1 is a schematic flowchart of an application development method according to an exemplary embodiment of the present application;

FIG. 2 is a flowchart illustrating another method for developing an application according to an exemplary embodiment of the present disclosure;

FIG. 3 is a flowchart illustrating a process of operating a scheduler according to an exemplary embodiment of the present application;

fig. 4 is a schematic structural diagram of an application development apparatus according to an exemplary embodiment of the present application;

fig. 5 is a schematic structural diagram of an application development device according to an exemplary embodiment of the present application.

Detailed Description

In order to make the objects, technical solutions and advantages of the present application more apparent, the technical solutions of the present application will be described in detail and completely with reference to the following specific embodiments of the present application and the accompanying drawings. It should be apparent that the described embodiments are only some of the embodiments of the present application, and not all of the embodiments. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present application.

In order to solve the problem that development environments of a plurality of application programs are mutually interfered when the plurality of application programs are developed simultaneously, in the embodiment of the application, development environments of different program objects are operated on a server, different component libraries are needed for the development environments of the different program objects, each program object corresponds to a subprocess to avoid mutual influence of the development environments of the different program objects, the different subprocesses are distributed with independent operation resources, the development environments of the different program objects are operated on the independent operation resources, when a client develops the program objects, the client develops the program objects based on the development environment corresponding to the program object on the server, and operation without mutual interference among the development environments for developing the different program objects is realized.

The technical solutions provided by the embodiments of the present application are described in detail below with reference to the accompanying drawings.

Fig. 1 is a flowchart illustrating an application development method according to an exemplary embodiment of the present application.

As shown in fig. 1, the method includes:

101. receiving a program development request aiming at a target program object sent by a target client, wherein the target program object is an application program or at least one functional module in the application program;

102. if the development environment of the target program object does not exist on the server, acquiring a development environment description file corresponding to a component library required by the target program object;

103. creating a target subprocess corresponding to a target program object, and allocating independent running resources for the target subprocess, wherein the server comprises at least one target subprocess corresponding to at least one target program object, and different running resources are allocated to target subprocesses corresponding to different target program objects;

104. controlling the target subprocess to create and operate a development environment of the target program object according to a development environment description file corresponding to the component library required by the corresponding target program object;

105. and providing the page data corresponding to the development environment of the target program object for the target client to display the program development page corresponding to the page data.

In this embodiment, the client may send a program development request to the server, where the program development request is used to request development of a program object. The program object may be an application program or at least one function module included in the application program. The types of applications may include, but are not limited to: any type of shopping, social contact, electronic product, rental and sale room or remote learning, and the functional modules of the application programs are different according to the application programs. For example, the functional modules of the rental store application may include, but are not limited to: the house source information issuing module, the remote house watching module or the house source searching module and the like; the functional modules of the shopping application may include, but are not limited to: the system comprises a commodity management module, an order management module, a multi-person group-piecing module or a power-assisted price-cutting module and the like; the functional modules of the social application may include, but are not limited to: the system comprises an online chatting module, a group chatting interaction module, a social circle module or a friend adding module and the like.

The client may send a program development request for one program object to the server, or the client may send multiple program development requests for different program objects to the server, which is not limited to this. In the case that a client sends a program development request for a program object to a server, the program object requested to be developed by the client can be an application program A or a functional module A1 of the application program A; in the case where there are a plurality of program objects requested to be developed by each client, the plurality of program objects may be the application a and the application B, the functional module A1 of the application a and the functional module B1 of the application B, the functional modules B2 of the application a and the application B, and the like, and the number is not limited thereto.

In this embodiment, the server may run a development environment of a plurality of program objects, the development environment is an operation environment on which the development program objects depend, the development environments of different program objects need to depend on different component libraries, and the environment dependencies of different component libraries are different, where the environment dependencies of a component library mainly refer to dependency package data needed by the component library. For example, web application A1 needs to rely on the Antd3 component library, and the environment dependency of the Antd3 component library is: act16, act-dom16, and moment.js2.2; the web application A2 needs to rely on the Fusion component library, and the environment dependence of the Fusion component library is as follows: act17, act-dom17, and moment.js2.5; the web application A3 needs to depend on the Element component library, and the environment dependence of the Element component library is as follows: vue3 and moment. Js2.1. The act is a JavaScript library for constructing a user interface, and the acts 16 and 17 are different versions of the act; the act-dom is a tool kit required to be used in an act development project, is a platform implementation for the dom, is mainly used for rendering at a web end, and belongs to different versions of the act-dom, wherein the act-dom16 and the act-dom17 are different versions of the act-dom; moment is a lightweight JavaScript time base, which facilitates the operation of time in daily development and improves the development efficiency, and moment 2.1, moment 2.2 and moment 2.5 are different versions of moment.

In the present embodiment, for convenience of distinction and description, a program object that needs to run a development environment on a server is referred to as a target program object, and a client that sends a program development request for the target program object is referred to as a target client. The number of the target program objects may be at least one, for example, the target program object may be one, or may be multiple, for example, 3 or 5. Accordingly, the number of target clients is not limited, and may be one, or may be multiple, such as 2 or 4, and the like. The target client may send a program development request for a target program object to the server, for example, one target client sends a program development request for one target program object to the server, or one target client sends a program development request for a plurality of target program objects to the server, or a plurality of target clients send a program development request for at least one target program object to the server, which is not limited herein.

In this embodiment, the server may receive a program development request sent by the target client, and the server may receive one or more program development requests, where the one or more program development requests are developed for at least one target program object. The following description will take the example where the server receives a program development request from a target client for a target program object, but is not limited thereto. The server determines the target program object for which the program development request is directed, and determines whether a development environment of the target program object exists, as shown in fig. 2.

In this embodiment, if the development environment of the target program object does not exist on the server, it is necessary to create a corresponding development environment on the server for the target program object. Specifically, a development environment description file corresponding to a component library required by the target program object may be obtained, and a development environment corresponding to the target program object may be created according to the development environment description file corresponding to the component library required by the target program object. The development environment description file defines various modules (such as libraries or frames) required for developing the program object, dependency package information required by the component library, configuration information (such as metadata of name, version, license and the like) of the program object and other description files. Alternatively, the development environment description file may be implemented as a package json file.

The development environment description file corresponding to the component library required by the target program object may be locally obtained from the server, the development environment description file corresponding to the component library required by the target program object may also be obtained from a third-party database, the client may also provide the storage address information of the development environment description file to the server, and the server obtains the development environment description file corresponding to the component library required by the target program object based on the storage address information, which is not limited to this.

In this embodiment, since the development environments of different program objects need to depend on different component libraries, and the environment dependencies of different component libraries are different, in the case of running the development environments of multiple target program objects on a server, in order to avoid the development environments of different program objects from affecting each other, it is necessary to provide independent running resources for the development environments of different program objects, where the independent running resources may include but are not limited to: memory, CPU or bandwidth, etc. Specifically, a target sub-process corresponding to the target program object may be created, an independent running resource may be allocated to the target sub-process corresponding to the target program object, and the target sub-process may be controlled to create the development environment of the target program object according to the development environment description file corresponding to the component library required by the corresponding target program object. For example, a target sub-process corresponding to the target program object may be controlled to start a command script (e.g., a shell script) for the target program object, parse the development environment description file line, and download and install a dependency package required by the component library according to a parsing result to create a development environment of the target program object.

In the above process, the execution sequence of creating the target sub-process corresponding to the target program object and obtaining the development environment description file corresponding to the component library required by the target program object is not limited. For example, a target sub-process corresponding to a target program object may be created first, and then a development environment description file corresponding to a component library required by the target program object may be acquired, for example, a development environment description file corresponding to a component library required by the target program object may be acquired first, and then a target sub-process corresponding to the target program object may be created, or a development environment description file corresponding to a component library required by the target program object may be acquired simultaneously, and a target sub-process corresponding to the target program object may be created, which is not limited herein.

In this embodiment, for a target program object for which a program development request is directed, after a development environment of the target program object is created, a development environment in which a target sub-process corresponding to the target program object runs the target program object may be controlled, where a server may include at least one target sub-process corresponding to at least one target program object, and in the case of multiple target program objects, different running resources are allocated to target sub-processes corresponding to different target program objects, and the target sub-processes corresponding to different target program objects may be controlled to run the development environments of the target program object, respectively, so as to implement non-interfering running between the development environments of different target program objects.

In this embodiment, for a target program object for which a program development request is directed, page data corresponding to a development environment of the target program object is provided to a target client, so that the target client displays a program development page corresponding to the page data, and a developer develops the target program object based on the program development page. The page data may include, but is not limited to: hypertext markup Language (HTML) data, cascading Style Sheets (CSS) data, and (js) data, among others.

In an optional embodiment, for a target program object targeted by a program development request, if a development environment of the target program object exists on a server, which indicates that the development environment of the target program object does not need to be created, at this time, it needs to be determined whether the development environment of the target program object is in a state of being run by a corresponding target subprocess, and if the development environment of the target program object is in a state of being run by a corresponding target subprocess, page data corresponding to the development environment of the target program object is provided to a target client, so that the target client displays a program development page corresponding to the page data.

Optionally, if a development environment of the target program object exists on the server and the development environment of the target program object is in a non-running state, which indicates that a target sub-process corresponding to the target program object does not exist on the server, creating a target sub-process corresponding to the target program object, allocating independent running resources for the target sub-process, controlling the target sub-process to run the development environment of the target program object, and providing page data corresponding to the development environment of the target program object to the target client, so that the target client displays a program development page corresponding to the page data.

In this embodiment, an implementation manner of obtaining the development environment description file corresponding to the component library required by the target program object is not limited. The following examples are given.

In an optional embodiment, the development environment description files corresponding to the component libraries required by different program objects are stored in the server-side local or third-party database, so that the development environment description files corresponding to the component libraries required by the target program objects can be directly acquired from the server-side local or third-party database.

In another optional embodiment, project data required for developing a target program object may be acquired, where the project data includes dependency package requirement information of a component library required for developing the target program object, and the dependency package requirement information is information that can be acquired by a name or a download address of a data package that the component library depends on, and the like; and merging the requirement information of the dependency package and the description file of the project template to obtain a development environment description file of the target program object. The description file of the project template contains basic configuration information required for developing the target program object, such as project name, version, license and other metadata.

Correspondingly, in the process that the control target sub-process creates a development environment corresponding to the target program object according to the development environment description file corresponding to the component library required by the corresponding target program object, a command script such as a shell script for the target program object can be started, the development environment description file is analyzed, dependency package requirement information of the component library required by the target program object is obtained, and a dependency package required by the component library is downloaded and installed according to the dependency package requirement information, so that the development environment of the target program object is created.

Optionally, each program object corresponds to an item identifier, where the item identifier may be an ID or a name of the program object, or a physical path or a version number of item data corresponding to the program object, and the like, which is not limited herein. The server maintains the incidence relation between different item identifiers and port numbers, and the program development request aiming at the target program object sent by the target client comprises the port number, so that the item identifier of the target program object can be acquired according to the port number by combining the incidence relation between the item identifier and the port number of the target program object; determining whether project data required by the target program object exists locally or not according to the project identification; and if so, acquiring project data required by the target program object from the local.

Further optionally, if the project data of the target program object does not exist locally, sending project data application prompt information to the target client corresponding to the target program object to prompt the target client to return development requirement information for the target program object, where the development requirement information may include address information of the project data of the target program object, such as download address information or storage address information in a database; the target client sends development requirement information of the target program object to the server, and the server can receive the development requirement information aiming at the target program object sent by the target client; and acquiring project data required by the target program object according to the development requirement information.

Further optionally, after the project data required by the target program object is acquired, a new project identifier may be generated, a new port number corresponding to the target program object is created, and the new port number is provided to the target client so that the target client sends a program development request for the target program object; and establishing an incidence relation between the new item identification and the new port number.

In an alternative embodiment, a countdown may be set for each target sub-process, which may be an hour, twenty-four hours, a week, a month, or the like, without limitation. The creation or reclamation of the sub-process is controlled by the countdown. Specifically, under the condition that the development environment corresponding to the target program object does not exist, after the target sub-process is controlled to create and run the development environment of the target program object, the target sub-process is added to a scheduling queue, and a countdown is set for the target sub-process in the scheduling queue, wherein the scheduling queue may include at least one target sub-process, and each target sub-process is provided with a countdown. When the countdown of the target subprocess is finished, if a program development request which is sent by a target client and aims at a target program object corresponding to the target subprocess is not received, the development environment of the target program object is in an idle state for a long time, the target subprocess is controlled to stop running the development environment of the target program object, independent running resources distributed for the target subprocess are released, and the target subprocess is destroyed.

Optionally, if a program development request for the target program object sent by the target client is received during the countdown period of the target subprocess, and the access frequency of the development environment of the target program object is high, and the development environment does not need to be stopped running, the countdown is performed on the target subprocess again.

In this embodiment, the server further includes a scheduler, and the scheduler is responsible for scheduling and managing the target sub-process. As shown in fig. 3, the operation process of the scheduler mainly includes the following steps: 1) An initialization scheduler, which is mainly used for configuring a scheduling queue (Running queue), a scheduling class (scheduled _ class), a scheduling domain (scheduled _ domain), a scheduling group (scheduled _ group), a root domain (root _ domain), a group scheduling (group _ scheduled), and the like; 2) Perfecting the management of the target subprocess mainly relates to the following steps: a) Configuring a monitoring mechanism for monitoring the scheduling condition of the target subprocess, and closing, recovering or emptying the project data of the target program object corresponding to the target subprocess according to the scheduling condition of the target subprocess, so that the scheduler has the target subprocess closing capability, the subprocess recovering capability and the physical emptying project capability; b) Configuring a recording function, configuring a countdown mechanism for each target subprocess, starting the target subprocess, then entering countdown, when a new user accesses a target program object corresponding to the target subprocess, then counting down again, when the countdown is 0, the target subprocess is indicated to be idle for a long time, then entering to recycle the target subprocess, and cleaning a port occupied by the target subprocess and operating resources occupied by the port; 3) And adding the target subprocess to the scheduling queue, and scheduling the target subprocess in the scheduling queue.

It should be noted that, the executing subjects of the steps of the method provided in the foregoing embodiments may be the same device, or different devices may also be used as the executing subjects of the method. For example, the execution subjects of steps 101 to 103 may be device a; for another example, the execution subject of

steps

101 and 102 may be device a, and the execution subject of step 103 may be device B; and so on.

In addition, in some of the flows described in the above embodiments and the drawings, a plurality of operations occurring in a specific order are included, but it should be clearly understood that these operations may be executed out of order or in parallel as they appear herein, and the sequence numbers of the operations, such as 101, 102, etc., are used merely to distinguish various operations, and the sequence numbers themselves do not represent any execution order. Additionally, the flows may include more or fewer operations, and the operations may be performed sequentially or in parallel. It should be noted that, the descriptions of "first", "second", etc. in this document are used for distinguishing different messages, devices, modules, etc., and do not represent a sequential order, nor limit the types of "first" and "second" to be different.

Fig. 4 is a schematic structural diagram of an application development apparatus according to an exemplary embodiment of the present application, and as shown in fig. 4, the apparatus includes: a receiving module 41, an obtaining module 42, a creating module 43, a control module 44, and a providing module 45;

a receiving module 41, configured to receive a program development request for a target program object sent by a target client, where the target program object is an application program or at least one functional module in the application program;

an obtaining module 42, configured to obtain a development environment description file corresponding to a component library required by a target program object if a development environment of the target program object does not exist on the application program development device;

a creating module 43, configured to create a target sub-process corresponding to a target program object and allocate independent running resources to the target sub-process, where the application development apparatus includes at least one target sub-process corresponding to at least one target program object, and different running resources are allocated to target sub-processes corresponding to different target program objects;

the control module 44 is used for controlling the target subprocess to create and run a development environment of the target program object according to the development environment description file corresponding to the component library required by the corresponding target program object;

and a providing module 45, configured to provide the target client with page data corresponding to the development environment of the target program object, so that the target client displays a program development page corresponding to the page data.

In an optional embodiment, the providing module 45 is further configured to provide, if a development environment of the target program object exists on the application development device and the development environment of the target program object is in a state of being executed by a corresponding target sub-process, the page data corresponding to the development environment of the target program object to the target client, so that the target client displays the program development page corresponding to the page data.

In an optional embodiment, if a development environment of the target program object exists on the application development device and the development environment of the target program object is in a non-running state, the creating module 43 is further configured to create a target sub-process corresponding to the target program object and allocate an independent running resource for the target sub-process, the controlling module 44 is configured to control the target sub-process to run the development environment of the target program object, and the providing module 45 is further configured to provide page data corresponding to the development environment of the target program object to the target client, so that the target client displays a program development page corresponding to the page data.

In an optional embodiment, the obtaining module 42 is specifically configured to: acquiring project data required by developing a target program object, wherein the project data comprises dependency package requirement information of a component library required by developing the target program object; and merging the requirement information of the dependency package and the description file of the project template to obtain a development environment description file of the target program object.

In an optional embodiment, the obtaining module 42 is specifically configured to: acquiring a project identifier of a target program object by combining an incidence relation between the project identifier and a port number of the target program object according to the port number in a program development request aiming at the target program object; determining whether project data required by the target program object exists locally or not according to the project identification; and if so, acquiring project data required by the target program object from the local.

In an optional embodiment, the application development device further comprises: the sending module is used for sending project data application prompt information to a target client corresponding to the target program object if the target program object does not exist, so as to prompt the target client to return development requirement information for the target program object; the receiving module 41 is further configured to receive development requirement information for the target program object sent by the target client; the obtaining module 42 is further configured to: and acquiring project data required by the target program object according to the development requirement information.

In an optional embodiment, the application development device further comprises: a generation module and an establishment module; the generating module is used for generating a new project identifier after acquiring project data required by the target program object; the creating module is also used for creating a new port number corresponding to the target program object; the providing module is further used for providing the new port number to the target client so that the target client can send a program development request aiming at the target program object; and the establishing module is used for establishing the incidence relation between the new item identification and the new port number.

In an optional embodiment, the application development device further comprises: the device comprises an adding module, a setting module and a processing module; the adding module is used for adding the target subprocess into the scheduling queue, and the setting module is used for setting countdown for the target subprocess when the target subprocess is added into the scheduling queue; and the processing module is used for controlling the target subprocess to stop running the development environment corresponding to the target program object, releasing independent running resources distributed for the target subprocess and destroying the target subprocess if a program development request which is sent by the target client and aims at the target program object corresponding to the target subprocess is not received when the countdown of the target subprocess is finished.

In an optional embodiment, the processing module is further configured to count down the target subprocess again if a program development request sent by the target client for the target program object is received during the countdown period of the target subprocess.

For a detailed implementation of the application development device, reference may be made to the foregoing embodiments, which are not described herein again. The application program development device provided by the embodiment of the application program runs development environments of different program objects on a server, the development environments of different program objects need different component libraries, in order to avoid the mutual influence of the development environments of different program objects, each program object corresponds to a subprocess, different subprocesses are distributed with independent running resources, the development environments of different program objects run on the independent running resources, when a client develops the program objects, the development environment corresponding to the program object on the server is developed, and the running without mutual interference between the development environments for developing different program objects is realized.

Fig. 5 is a schematic structural diagram of an application development device according to an exemplary embodiment of the present application. As shown in fig. 5, the apparatus includes: a memory 54 and a processor 55.

Memory 54 for storing computer programs and may be configured to store other various data to support operations on the application development device. Examples of such data include instructions for any application or method operating on the application development device.

The memory 54 may be implemented by any type or combination of volatile or non-volatile memory devices, such as Static Random Access Memory (SRAM), electrically erasable programmable read-only memory (EEPROM), erasable programmable read-only memory (EPROM), programmable read-only memory (PROM), read-only memory (ROM), magnetic memory, flash memory, magnetic or optical disks.

A processor 55 coupled to the memory 54 for executing computer programs in the memory 54 for: receiving a program development request aiming at a target program object sent by a target client, wherein the target program object is an application program or at least one functional module in the application program; if the development environment of the target program object does not exist on the server, acquiring a development environment description file corresponding to a component library required by the target program object; creating a target subprocess corresponding to a target program object, and allocating independent running resources for the target subprocess, wherein the server comprises at least one target subprocess corresponding to at least one target program object, and different running resources are allocated to target subprocesses corresponding to different target program objects; controlling the target subprocess to create and operate a development environment of the target program object according to a development environment description file corresponding to the component library required by the corresponding target program object; and providing the page data corresponding to the development environment of the target program object for the target client to display the program development page corresponding to the page data.

In an alternative embodiment, processor 55 is further configured to: and if the development environment of the target program object exists on the server and the development environment of the target program object is in a state of being operated by the corresponding target sub-process, providing page data corresponding to the development environment of the target program object for the target client so that the target client can display a program development page corresponding to the page data.

In an alternative embodiment, processor 55 is further configured to: if the development environment of the target program object exists on the server side and the development environment of the target program object is in a non-running state, creating a target sub-process corresponding to the target program object, distributing independent running resources for the target sub-process, controlling the target sub-process to run the development environment of the target program object, and providing page data corresponding to the development environment of the target program object for the target client side to display a program development page corresponding to the page data.

In an optional embodiment, when obtaining the development environment description file corresponding to the component library required by the target program object, the processor 55 is specifically configured to: acquiring project data required by developing a target program object, wherein the project data comprises dependency package requirement information of a component library required by developing the target program object; and merging the requirement information of the dependency package and the description file of the project template to obtain a development environment description file of the target program object.

In an alternative embodiment, when acquiring the project data required for developing the target program object, the processor 55 is specifically configured to: acquiring a project identifier of a target program object according to a port number in a program development request aiming at the target program object and by combining an incidence relation between the project identifier and the port number of the target program object; determining whether project data required by the target program object exists locally or not according to the project identification; and if so, acquiring project data required by the target program object from the local.

In an alternative embodiment, processor 55 is further configured to: if the target program object does not exist, sending project data application prompt information to a target client corresponding to the target program object so as to prompt the target client to return development requirement information aiming at the target program object; receiving development requirement information aiming at a target program object sent by a target client; and acquiring project data required by the target program object according to the development requirement information.

In an alternative embodiment, after obtaining the item data required by the target program object, the processor 55 is further configured to: generating a new project identifier, creating a new port number corresponding to the target program object, and providing the new port number to the target client so that the target client can send a program development request aiming at the target program object; and establishing an incidence relation between the new item identification and the new port number.

In an alternative embodiment, after controlling the development environment in which the target sub-process runs the target program object, the processor 55 is further configured to: adding the target subprocess to a scheduling queue, and setting countdown for the target subprocess when the target subprocess is added to the scheduling queue; and when the countdown of the target subprocess is finished, if a program development request which is sent by the target client and aims at the target program object corresponding to the target subprocess is not received, controlling the target subprocess to stop running the development environment of the target program object, releasing the independent running resource distributed for the target subprocess, and destroying the target subprocess.

In an alternative embodiment, processor 55 is further configured to: and if a program development request aiming at the target program object sent by the target client side is received during the countdown period of the target subprocess, the countdown is carried out on the target subprocess again.

For a detailed implementation of the application development device, reference may be made to the foregoing embodiments, which are not described herein again. The application program development equipment provided by the embodiment of the application program runs development environments of different program objects on the server side, the development environments of the different program objects need different component libraries, each program object corresponds to a subprocess, the different subprocesses are distributed with independent running resources, the development environments of the different program objects run on the independent running resources, and when the client side develops the program objects, the development environment corresponding to the program object on the server side is developed, so that the running of the development environments of the different program objects without mutual interference is realized.

Further, as shown in fig. 5, the application development device further includes: communication components 56, display 57, power components 58, audio components 59, and the like. Only some of the components are schematically shown in fig. 5, and it is not meant that the application development apparatus includes only the components shown in fig. 5. It should be noted that the components within the dashed box in fig. 5 are optional components, not necessary components, and may be determined according to the product form of the application development device.

Accordingly, the present application also provides a computer readable storage medium storing a computer program, which, when executed by a processor, causes the processor to implement the steps of the method shown in fig. 1 provided by the present application.

The communication component of fig. 5 described above is configured to facilitate communication between the device in which the communication component is located and other devices in a wired or wireless manner. The device where the communication component is located can access a wireless network based on a communication standard, such as WiFi, a mobile communication network such as 2G, 3G, 4G/LTE, 5G, or the like, or a combination thereof. In an exemplary embodiment, the communication component receives a broadcast signal or broadcast related information from an external broadcast management system via a broadcast channel. In one exemplary embodiment, the communication component further includes a Near Field Communication (NFC) module to facilitate short-range communications. For example, the NFC module may be implemented based on Radio Frequency Identification (RFID) technology, infrared data association (IrDA) technology, ultra Wideband (UWB) technology, bluetooth (BT) technology, and other technologies.

The display in fig. 5 described above includes a screen, which may include a Liquid Crystal Display (LCD) and a Touch Panel (TP). If the screen includes a touch panel, the screen may be implemented as a touch screen to receive an input signal from a user. The touch panel includes one or more touch sensors to sense touch, slide, and gestures on the touch panel. The touch sensor may not only sense the boundary of a touch or slide action, but also detect the duration and pressure associated with the touch or slide operation.

The power supply assembly of fig. 5 described above provides power to the various components of the device in which the power supply assembly is located. The power components may include a power management system, one or more power supplies, and other components associated with generating, managing, and distributing power for the device in which the power component is located.

The audio component of fig. 5 described above may be configured to output and/or input an audio signal. For example, the audio component includes a Microphone (MIC) configured to receive an external audio signal when the device in which the audio component is located is in an operational mode, such as a call mode, a recording mode, and a voice recognition mode. The received audio signal may further be stored in a memory or transmitted via a communication component. In some embodiments, the audio assembly further comprises a speaker for outputting audio signals.

As will be appreciated by one skilled in the art, embodiments of the present application may be provided as a method, system, or computer program product. Accordingly, the present application may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present application may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, and so forth) having computer-usable program code embodied therein.

The present application is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the application. It will be understood that each flow and/or block of the flowchart illustrations and/or block diagrams, and combinations of flows and/or blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.

These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including instruction means which implement the function specified in the flowchart flow or flows and/or block diagram block or blocks.

These computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide steps for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.

In a typical configuration, a computing device includes one or more processors (CPUs), input/output interfaces, network interfaces, and memory.

The memory may include forms of volatile memory in a computer readable medium, random Access Memory (RAM) and/or non-volatile memory, such as Read Only Memory (ROM) or flash memory (flash RAM). Memory is an example of a computer-readable medium.

Computer-readable media, including both non-transitory and non-transitory, removable and non-removable media, may implement information storage by any method or technology. The information may be computer readable instructions, data structures, modules of a program, or other data. Examples of computer storage media include, but are not limited to, phase change memory (PRAM), static Random Access Memory (SRAM), dynamic Random Access Memory (DRAM), other types of Random Access Memory (RAM), read Only Memory (ROM), electrically Erasable Programmable Read Only Memory (EEPROM), flash memory or other memory technology, compact disc read only memory (CD-ROM), digital Versatile Disks (DVD) or other optical storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other non-transmission medium, which can be used to store information that can be accessed by a computing device. As defined herein, a computer readable medium does not include a transitory computer readable medium such as a modulated data signal and a carrier wave.

It should also be noted that the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus. Without further limitation, an element defined by the phrases "comprising a," "8230," "8230," or "comprising" does not exclude the presence of other like elements in a process, method, article, or apparatus comprising the element.

The above description is only an example of the present application and is not intended to limit the present application. Various modifications and changes may occur to those skilled in the art. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present application should be included in the scope of the claims of the present application.

Claims

1. An application development method is applicable to a server and comprises the following steps:

receiving a program development request aiming at a target program object sent by a target client, wherein the target program object is an application program or at least one functional module in the application program;

if the development environment of the target program object does not exist on the server, acquiring a development environment description file corresponding to a component library required by the target program object;

creating a target subprocess corresponding to the target program object, and allocating independent running resources for the target subprocess, wherein the server comprises at least one target subprocess corresponding to at least one target program object, and different running resources are allocated to target subprocesses corresponding to different target program objects;

controlling the target subprocess to create and operate a development environment of the target program object according to a development environment description file corresponding to a component library required by the corresponding target program object;

and providing the page data corresponding to the development environment of the target program object to the target client so that the target client can display the program development page corresponding to the page data.

2. The method of claim 1, further comprising:

and if the development environment of the target program object exists on the server and the development environment of the target program object is in a state of being operated by a corresponding target subprocess, providing page data corresponding to the development environment of the target program object for the target client to display a program development page corresponding to the page data.

3. The method of claim 2, further comprising:

if the development environment of the target program object exists on the server and the development environment of the target program object is in a non-running state, creating a target sub-process corresponding to the target program object, distributing independent running resources for the target sub-process, controlling the target sub-process to run the development environment of the target program object, and providing page data corresponding to the development environment of the target program object to the target client so that the target client can display a program development page corresponding to the page data.

4. The method of claim 1, wherein obtaining the development environment description file corresponding to the component library required by the target program object comprises:

acquiring project data required by developing the target program object, wherein the project data comprises dependency package requirement information of a component library required by developing the target program object;

and merging the requirement information of the dependency package and the description file of the project template to obtain the development environment description file of the target program object.

5. The method of claim 4, wherein the obtaining project data required to develop the target program object comprises:

acquiring a project identifier of the target program object according to a port number in a program development request aiming at the target program object and by combining an incidence relation between the project identifier and the port number of the target program object;

determining whether project data required by the target program object exists locally or not according to the project identification;

and if so, acquiring project data required by the target program object from the local.

6. The method of claim 5, further comprising:

if the target program object does not exist, sending project data application prompt information to a target client corresponding to the target program object so as to prompt the target client to return development requirement information for the target program object;

receiving development requirement information aiming at the target program object sent by the target client;

and acquiring project data required by the target program object according to the development requirement information.

7. The method according to claim 5 or 6, further comprising, after acquiring the item data required by the target program object:

generating a new project identifier, creating a new port number corresponding to the target program object, and providing the new port number to the target client so that the target client can send a program development request aiming at the target program object;

and establishing an incidence relation between the new item identification and the new port number.

8. The method of any of claims 1-3, further comprising, after controlling the development environment in which the target sub-process runs the target program object:

adding the target subprocess to a scheduling queue, and setting countdown for the target subprocess when the target subprocess is added to the scheduling queue;

and when the countdown of the target subprocess is finished, if a program development request which is sent by a target client and aims at a target program object corresponding to the target subprocess is not received, controlling the target subprocess to stop running the development environment of the target program object, releasing independent running resources distributed for the target subprocess, and destroying the target subprocess.

9. The method of claim 8, further comprising:

and if a program development request aiming at the target program object sent by a target client is received during the countdown period of the target subprocess, counting down the target subprocess again.

10. An application development apparatus, comprising: the device comprises a receiving module, an obtaining module, a creating module, a control module and a providing module;

the receiving module is used for receiving a program development request aiming at a target program object sent by a target client, wherein the target program object is an application program or at least one functional module in the application program;

the acquisition module is used for acquiring a development environment description file corresponding to a component library required by the target program object if the development environment of the target program object does not exist on the application program development device;

the creating module is used for creating a target subprocess corresponding to the target program object and allocating independent running resources to the target subprocess, wherein the application program developing device comprises at least one target subprocess corresponding to at least one target program object, and different running resources are allocated to target subprocesses corresponding to different target program objects;

the control module is used for controlling the target subprocess to establish and run a development environment of the target program object according to a development environment description file corresponding to the component library required by the corresponding target program object;

the providing module is used for providing the target client with the page data corresponding to the development environment of the target program object so that the target client can display the program development page corresponding to the page data.

11. An application development device, comprising: a memory and a processor; the memory for storing a computer program; the processor, coupled to the memory, is configured to execute the computer program to implement the steps of the method of any of claims 1-9.

12. A computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, causes the processor to carry out the steps of the method according to any one of claims 1 to 9.