A deployment method for a client / server application and related equipment

Abstract

This application provides a method and related equipment for deploying a client / server (C / S) application to a cloud server, thereby reducing operational costs. The method includes: obtaining the source code and resource files of a C / S application project; determining programming language commands in the source code files and generating a programming language file based on these commands; generating a client application file based on the source code and resource files; generating a network application interface (API) based on the API; generating a background service program based on the API; deploying the API and background service program on the application server of the cloud server; deploying the client application file on the network server of the cloud server; deploying an application database and a background database, binding the application database to the API, and binding the background database to the background service program, to complete the deployment of the C / S application project.

Description

Technical Field

[0001] This application relates to the field of software development, and more particularly to a deployment method and related equipment for a C / S application. Background Technology

[0002] Client / server (C / S) applications are based on a client / server architecture, a widely adopted software system architecture in the software development field. While technically mature, C / S architecture is characterized by its suitability for local area networks (LANs), strong interactivity, low network traffic, fast response times, and ability to handle large amounts of data. However, each client machine requires a corresponding client program, hindering rapid deployment, installation, and configuration, and making upgrades and maintenance difficult. Furthermore, applications typically access data directly through database connections, posing significant security risks, which further limits its application to LANs.

[0003] Because the client / server architecture is mainly used in local area networks, each client machine needs to install the corresponding client program. Enterprises also need to deploy their own network, server and database hardware and software environment, and maintain these environments. This is a continuous and heavy task, which generally requires professional system maintenance personnel.

[0004] Therefore, how to deploy C / S applications while minimizing operation and maintenance costs is a pressing technical challenge that needs to be addressed. Summary of the Invention

[0005] This application provides a method and related equipment for deploying C / S applications to cloud servers and reducing operation and maintenance costs.

[0006] The first aspect of this application provides a method for deploying a C / S application, applied to the development end, the method comprising:

[0007] Obtain the source code and resource files of the C / S application project;

[0008] The programming language commands are determined in the source code file, and a programming language file is generated based on the programming language commands;

[0009] A client application file is generated based on the source code file and the resource file; wherein, the client application file is the application file of the client's application.

[0010] An interface project is generated based on the programming language file, and the interface project is compiled to generate an interface service program file, which is then used to generate a network application interface; a background service project is generated based on the programming language file, and the background service project is compiled to generate a background service program file, which is then used to generate a background service program.

[0011] The network application interface and the background service program are deployed on the application server of the cloud server; the client application file is deployed on the network server of the cloud server.

[0012] Deploy an application database and a backend database, and bind the application database to the network application interface and the backend database to the backend service program to complete the deployment of the C / S application project; wherein, the application database is used by the client to access through the network application interface, and the backend database is used to store the session information between the client and the cloud server.

[0013] Optionally, generating a program language file based on the program language commands includes:

[0014] Separate flow control statements and language structure statements from the programming language commands, and generate statement identification information corresponding to the language structure statements;

[0015] The statement identification information is designated as the call identifier of the network application interface of the cloud server, and the program language file is generated according to the flow control statement, the language structure statement and the statement identification information.

[0016] Optionally, if the client application file includes a binary program file and a dependency file, generating the client application file from the source code file includes:

[0017] Generate a dependency file between any two source code files; wherein the dependency file is used to characterize the mutual calling relationship between the two source code files;

[0018] Based on the dependency file, generate different binary program files corresponding to any two source code files.

[0019] Optionally, if the client application file includes an executable file and a homepage file, generating the client application file based on the source code file and the resource file includes:

[0020] The C / S application project is compiled based on the source code file to generate the executable file; wherein, the executable file is used to represent the program entry point of the client application;

[0021] A homepage file corresponding to the application of the client is generated based on the resource file; wherein, the homepage file is used to launch the executable file.

[0022] Optionally, before deploying the application database and the backend database, the method further includes:

[0023] The client service program file is deployed on the network server of the cloud server, and the client service program is deployed on the client according to the client service program file; wherein, the client service program file is a program file used to provide services for the client's application, and the client service program is used to install the client's application.

[0024] A second aspect of this application provides a method for deploying a client / server application, applied to a cloud server, the cloud server including a network server and an application server, the method comprising:

[0025] The application receives an interface service program file from the development end and deploys the generated network application interface on the application server based on the interface service program file; it also receives a background service program file from the development end and deploys the generated background service program on the application server based on the background service program file.

[0026] Receive the client application file sent by the development terminal, and deploy the client application file on the network server;

[0027] The application database is bound to the network application interface, and the backend database is bound to the backend service program to complete the deployment of the C / S application project on the cloud server; wherein, the application database is used by the client to access through the network application interface, and the backend database is used to store the session information between the client and the cloud server.

[0028] Optionally, the method further includes:

[0029] When the client application starts and the network server receives a session request, it calls the network application interface to create a session identifier; wherein, the session identifier is used for information interaction between the client application and the network server;

[0030] The session identifier and the user login information corresponding to the client are stored in the background database;

[0031] Alternatively, when the network server receives an access request, it retrieves an application connection object from the application database and configures the number of connection objects for each application connection object and the application connection parameters between each application connection object and the application database, so as to process the access request according to the configured application connection objects.

[0032] Optionally, the method further includes:

[0033] When the client's local storage space meets the update triggering conditions, the updated dependency file and the updated executable file are sent to the client; wherein, the update triggering conditions include the client's local storage space not containing the updated dependency file and the updated executable file, or the cloud server receiving one or more of the updated dependency file and the updated executable file sent by the development end; the dependency file is used to represent the mutual calling relationship between any two source codes of the C / S application project, and the executable file is used to represent the program entry point of the client's application.

[0034] A third aspect of this application provides a deployment system for a C / S application, comprising:

[0035] The acquisition unit is used to acquire the source code files and resource files of the C / S application project.

[0036] A determining unit is used to determine programming language commands in the source code file and generate a programming language file based on the programming language commands;

[0037] A generation unit is configured to generate a client application file based on the source code file and the resource file; wherein the client application file is the application file of the client's application.

[0038] The generation unit is further configured to generate an interface project based on the programming language file, compile the interface project to generate an interface service program file, and generate a network application interface based on the interface service program file; generate a background service project based on the programming language file, compile the background service project to generate a background service program file, and generate a background service program based on the background service program file.

[0039] The deployment unit is used to deploy the network application interface and the background service program on the application server of the cloud server; and to deploy the client application file on the network server of the cloud server.

[0040] The deployment unit is further configured to deploy an application database and a backend database, and bind the application database to the network application interface and the backend database to the backend service program to complete the deployment of the C / S application project; wherein, the application database is used by the client to access through the network application interface, and the backend database is used to store session information between the client and the cloud server.

[0041] The C / S application deployment system provided in the third aspect of this application is used to execute the C / S application deployment method described in the first aspect.

[0042] A fourth aspect of this application provides a deployment system for a C / S application, comprising:

[0043] The receiving unit is configured to receive the interface service program file sent by the development end, and deploy the generated network application interface on the application server based on the interface service program file; and to receive the background service program file sent by the development end, and deploy the generated background service program on the application server based on the background service program file.

[0044] The receiving unit is also used to receive the client application file sent by the development end and deploy the client application file on the network server;

[0045] The deployment unit is used to bind the application database to the network application interface and the backend database to the backend service program to complete the deployment of the C / S application project on the cloud server; wherein, the application database is used by the client to access through the network application interface, and the backend database is used to store the session information between the client and the cloud server.

[0046] The C / S application deployment system provided in the fourth aspect of this application is used to execute the C / S application deployment method described in the second aspect.

[0047] A fifth aspect of this application provides a deployment apparatus for a C / S application, comprising:

[0048] Central processing unit, memory, input / output interfaces, wired or wireless network interfaces, and power supply;

[0049] The memory is either a short-term storage memory or a persistent storage memory;

[0050] The central processing unit is configured to communicate with the memory and execute instructions in the memory to perform the deployment method of the C / S application described in the first aspect.

[0051] A sixth aspect of this application provides a computer-readable storage medium including instructions that, when executed on a computer, cause the computer to perform the deployment method of the C / S application described in the first aspect.

[0052] A fifth aspect of this application provides a computer program product, the computer program product including instructions that, when executed on a computer, cause the computer to perform the C / S application deployment method described in the first aspect.

[0053] As can be seen from the above technical solutions, the embodiments of this application have the following advantages: Through the C / S application deployment method disclosed in this application embodiment, the development end executes a deployment process to publish the C / S application project to a cloud server (including an application server and a network server), and then the client accesses the application deployed on the cloud server. Therefore, through the above technical implementation, the C / S application project can function like a web application; it can be accessed not only through a webpage but also through sessions between the client and the cloud server, thus greatly improving the user experience. Furthermore, the technical solution of this application only requires implementing one deployment process to publish existing C / S application projects or newly developed projects to the cloud without requiring developers to modify the relevant program code, which greatly improves the maintainability of the project. Attached Figure Description

[0054] To more clearly illustrate the technical solutions in the embodiments of this application, the accompanying drawings used in the description of the embodiments will be briefly introduced below. Obviously, the accompanying drawings described below are only some embodiments recorded in this application. For those skilled in the art, other drawings can be obtained based on these drawings.

[0055] Figure 1 This is a schematic diagram of a C / S application deployment architecture disclosed in an embodiment of this application;

[0056] Figure 2 This is a flowchart illustrating a deployment method for a C / S application applied to the development side, as disclosed in an embodiment of this application.

[0057] Figure 3 This is a flowchart illustrating another deployment method for a C / S application applied to the development side, as disclosed in an embodiment of this application.

[0058] Figure 4 This is a flowchart illustrating a deployment method for a C / S application applied to a cloud server, as disclosed in an embodiment of this application.

[0059] Figure 5This is a flowchart illustrating another deployment method for a C / S application applied to a cloud server, as disclosed in an embodiment of this application.

[0060] Figure 6 This is a schematic diagram of the structure of a deployment system for a C / S application applied to the development side, as disclosed in an embodiment of this application;

[0061] Figure 7 This is a schematic diagram of the structure of a C / S application deployment system for a cloud server disclosed in an embodiment of this application;

[0062] Figure 8 This is a schematic diagram of the structure of a C / S application deployment device disclosed in an embodiment of this application. Detailed Implementation

[0063] Client / server (C / S) applications are widely used in software development. The C / S architecture is technically mature, and its main characteristics are its applicability to local area networks (LANs), strong interactivity, low network traffic, fast response speed, and suitability for handling large amounts of data. However, each client machine in this architecture requires the installation of a corresponding client program, hindering rapid deployment, installation, and configuration, and making upgrades and maintenance difficult. Furthermore, applications typically access data directly through database connections, posing significant security risks, which also limits its primary application to LANs.

[0064] Because client / server (C / S) architecture is primarily used in local area networks (LANs), each client machine needs to install corresponding client software. Enterprises also need to deploy their own network, server, and database hardware and software environments, and maintain these environments—a continuous and demanding task typically requiring dedicated system administrators. Deploying C / S applications to a cloud platform can not only help enterprises reduce operational costs but also retain the advantages of C / S applications. In recent years, cloud technology has developed rapidly, and major cloud vendors have provided many valuable software infrastructure services, including computing, storage, networking, security, management and monitoring, databases, development tools, deployment tools, and other services. Among these, we can utilize virtual machines or containers within computing services to deploy C / S applications as servers and use database services to access data.

[0065] Currently, there are two main methods for deploying and running C / S applications to the cloud: First, cloud deployment plus remote desktop access for clients. This method requires deploying the client program to a cloud server (requiring an installation process) and the database to the cloud. Then, the client can directly run the installed application by connecting to the cloud server via remote desktop. However, this method requires numerous cloud servers to support multiple users, and its response performance demands high network bandwidth, leading to high costs and compatibility issues with external devices such as printers and monitors. Second, cloud deployment plus client download program. This method requires uploading and deploying the client program files to a cloud server (without an installation process) and the database to the cloud. Simultaneously, a download program (including a launcher) is installed on each client. The first time the client application is launched, the downloader needs to download all program files to the client before it can run. Since the application runs on the client and directly connects to the database deployed in the cloud, this poses significant security risks in an internet environment. Furthermore, it cannot provide features like Uniform Resource Locator (URL) access, on-demand file downloads, and background control found in web applications.

[0066] As can be seen from the above description, there are many obvious shortcomings in using existing methods to deploy and run C / S applications in the cloud. However, in the context of the trend of everything moving to the cloud, finding an effective solution for deploying and running C / S applications in the cloud will become a problem that every software development vendor must face.

[0067] The technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, and not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.

[0068] Please see Figure 1 , Figure 1 This is a schematic diagram of the deployment architecture of a C / S application disclosed in an embodiment of this application.

[0069] Depend on Figure 1As can be seen, the embodiments of this application mainly involve deploying C / S applications to the cloud and running them on the client side. This primarily involves four components: the development end (mainly for deploying C / S application projects), the client (mainly for users to operate on a browser, downloading client service programs to operate the installed application), the cloud server (including a web server and an application server), and the cloud database (including an application database and a backend database). The client can be a smartphone, tablet, laptop, desktop computer, PDA, mobile internet device (MID), wearable device (e.g., smartwatch, smart bracelet), smart computer, smart vehicle, or other smart terminal. The cloud server can establish a communication connection with the client. This cloud server can be an independent physical server, a server cluster composed of multiple physical servers, or a distributed system. It can also be a cloud server providing basic cloud computing services such as cloud databases, cloud services, cloud computing, cloud functions, cloud storage, network services, cloud communication, middleware services, domain name services, security services, CDN, and big data and artificial intelligence platforms. The client can have an application (or client-server program) installed. When this application runs on the client, it can interact with the above-mentioned... Figure 1 The cloud server shown interacts with the client to receive business data (such as UGC videos uploaded by users through the client). This application can be a social application, instant messaging application, live streaming application, game application, short video application, video application, music application, karaoke application, shopping application, novel application, payment application, or any other application with the ability to display text, images, audio, and video data. The specific application can be determined based on the actual application scenario requirements and is not limited here. This application can be installed on a standalone client or as an embedded sub-client integrated into a client (such as an instant messaging client, social client, etc.), depending on the actual application scenario and is not limited here.

[0070] The development team executes a deployment process, publishing the application project to a cloud server (comprising a Web Server and an Application Server). Clients then access the application deployed on the cloud server using a browser. Upon first access, a welcome page appears prompting users to click a link to install the client service program; subsequent accesses will directly launch the application. The application startup process primarily involves downloading the necessary dependency files from the application directory of the Web Server (web service) deployed on the cloud server. Once the client application starts, it accesses the application database in the cloud by calling the Web API of the Application Server deployed on the cloud server. Simultaneously, the client application is monitored by a background service program, and the monitoring information is stored in the cloud's backend database.

[0071] Details will be described in more detail later.

[0072] To facilitate Figure 1 For a detailed description of the development interface shown, please refer to [link / reference]. Figure 2 , Figure 2 This is a flowchart illustrating a deployment method for a C / S application applied to the development side, as disclosed in an embodiment of this application. It includes steps 201-206.

[0073] 201. Obtain the source code files and resource files of the C / S application project.

[0074] It should be noted beforehand that various C / S application database development tools can be used on the development side in this embodiment. For ease of illustration and description, PowerBuilder will be used as the development tool for the C / S application database in this embodiment. Specifically, PowerScript will be used as the programming language, and it has numerous example systems in the database application field (such as medical, banking, and telecommunications systems). This embodiment will use a PowerBuilder application project as an example to describe the specific implementation process and method in detail.

[0075] Specifically, before deploying a C / S application, it is necessary to obtain the source code files and resource files related to the C / S application project. The source code files can be understood as some raw program code in the development tool PowerBuilder, while the resource files include webpage caches, images, language packs, etc. Since source code files and resource files are complex and varied, they will not be illustrated one by one. One possible scenario will be explained later, but will not be elaborated upon here.

[0076] 202. Determine the programming language commands in the source code file and generate the programming language file based on the programming language commands.

[0077] Then, after determining the source code file, it is necessary to analyze the relevant program commands from the source code. Specifically, the program language commands are determined from the source code file, and a program language file is generated based on the program language commands.

[0078] In one specific embodiment, it is necessary to separate the Structured Query Language (SQL) commands from the source code file and generate a separate SQL file. It should be noted that SQL is a standardized language for managing relational database systems. Specifically, PowerScript programming language and SQL code are located in the source code file. The PowerScript and SQL code are then separated and replaced with SQL commands (programming language commands), resulting in the final SQL file (programming language file).

[0079] 203. Generate client application files based on source code files and resource files.

[0080] After completing step 201, you can proceed directly to step 203. Specifically, this involves generating the client application file based on the source code and resource files. It should be noted that the client application file is the application file for the client application.

[0081] In one specific embodiment, it can be combined with Figure 1 As shown, client application files associated with the application can be generated in the web server of the cloud server based on source code files and resource files. These include, but are not limited to, executable files (EXE), binary program files, home page files (index.html), or dependency files. Furthermore, there can also be resource files (which can be converted into files that can be loaded and opened by the client or web page).

[0082] 204. Generate an interface project based on the programming language file, compile the interface project to generate an interface service program file, and generate a network application interface based on the interface service program file; generate a backend service project based on the programming language file, compile the backend service project to generate a backend service program file, and generate a backend service program based on the backend service program file.

[0083] Subsequently, after step 202, an interface project can be generated based on the programming language file, and then the interface project can be compiled to generate an interface service program file. A network application interface is then generated based on the interface service program file. Simultaneously, a background service project can also be generated based on the programming language file, and then the background service project can be compiled to generate a background service program file, which in turn generates a background service program.

[0084] In one specific embodiment, it should be noted that, by Figure 1As shown, Web API stands for Web Application Programming Interface, typically based on the Hypertext Transfer Protocol (HTTP). It can be implemented in different programming languages ​​to provide network communication between applications. A typical Web API project consists of three parts: a Controller, a Service layer, and a Data Access Object (DAO). The DAO enables database access; however, the specific implementation of Web API will not be elaborated here. It's important to note that the DAO's primary function is data manipulation, which falls under the data layer in the standard application development architecture. In short, the Controller layer calls the Service layer, and the Service layer calls the DAO layer, thus completing the system's business logic, processing, and data access functions. The Controller layer can also validate and verify data submitted by the client, ensuring its legality and correctness. The Controller layer handles user requests, controlling and coordinating the entire application's workflow. It accepts user input, calls the corresponding Service layer to process business logic, and returns the results to the client. For example, a UserController can be used to handle and control user requests, enabling operations such as user login, registration, and information modification. The Service layer is the business logic processing center of the entire system, responsible for processing and calculating business data and returning the results to the Controller layer. In addition, the Service layer also needs to call the DAO layer to access and manipulate data to complete business logic processing. By standardizing and encapsulating the functions provided by the DAO layer, more complex operations can be implemented, such as user registration, login, and information modification. The DAO layer is used to access the database, responsible for performing data access and operations, including database access and operations, file system access, etc. It interacts with the database, and tasks related to communicating with the database are encapsulated here. Sending SQL statements to the database enables CRUD operations. It provides data access support and services to the Service layer, hiding the details of data access and providing a set of simple and easy-to-use interfaces for the Service layer to call and use.

[0085] Furthermore, the SQL file (programming language file) generated in the above steps needs to be included in the Web API project. Therefore, the corresponding compilation tools need to be called to compile the SQL file into a Web API service program file. Specifically, the SQL file generates the interface project (Web API project), which is then compiled to generate the interface service program file (Web API service program file). Finally, the Web API service program file is encapsulated into a web application interface, i.e., a Web API interface.

[0086] In addition, a backend service project needs to be generated and compiled to generate the backend service program file. Specifically, this process requires generating a backend service project, which is mainly used to manage client sessions, database connection configurations, and client requests. The design of these backend management functions will be explained again in the backend management section. Like Web API, the backend service project can be implemented using different programming languages, and then the corresponding compilation tools are used to compile it into a backend service program file. In this embodiment, the backend service project is generated from an SQL file, then compiled to generate the backend service program file, and finally, the backend service program is generated based on this file. Figure 1 The background services shown.

[0087] 205. Deploy the network application programming interface and backend service program on the application server of the cloud server; deploy the client application files on the network server of the cloud server.

[0088] Therefore, based on the above steps, the network application programming interface and backend service program can be deployed on the application server of the cloud server; and the client application files can be deployed on the network server of the cloud server.

[0089] In one specific embodiment, the Web API and background service program files are deployed to the Application Server on the cloud server. Since the Web API and background service program files have already been generated in the previous steps, this process only requires calling HTTP, FTP, or other file transfer tools to upload and deploy them to the Application Server.

[0090] 206. Deploy the application database and the backend database, bind the application database to the web application interface, and bind the backend database to the backend service program to complete the deployment of the C / S application project.

[0091] Furthermore, after deploying the Application Server and Web Server on the cloud server, it is also necessary to deploy the application database and the backend database. Then, the application database is bound to the web application interface, and the backend database is bound to the backend service program, thus completing the deployment of the C / S application project. It should be noted that the application database is used by clients to access the application through the web application interface, while the backend database stores session information between the client and the cloud server.

[0092] In one specific embodiment, the application database and the backend database provide data access services to the Web API and the backend service program, respectively. The application database is a client database, which is accessed by client applications through the Web API.

[0093] This embodiment discloses a C / S application deployment method where the development end executes a deployment process to publish the C / S application project to a cloud server (comprising an application server and a web server). The client then accesses the application deployed on the cloud server. Thus, through this technical implementation, the C / S application project can function like a web application, accessible not only through a webpage but also through client-cloud server interactions, significantly improving the user experience. Furthermore, this technical solution requires only one deployment process to publish existing or newly developed C / S application projects to the cloud without requiring developers to modify the relevant code, greatly enhancing project maintainability.

[0094] To further explain Figure 2 For the illustrated embodiment, please refer to [link / reference]. Figure 3 , Figure 3 This is a flowchart illustrating another deployment method for a C / S application on the development side, as disclosed in an embodiment of this application. It includes steps 301-310.

[0095] 301. Determine the programming language commands in the source code file, separate the flow control statements and language structure statements from the programming language commands, and generate statement identification information corresponding to the language structure statements.

[0096] In this embodiment, steps 301-302 are the same as those described above. Figure 2 Step 201 is similar. However, it should be noted that in this embodiment, the programming language commands can be determined in the source code file. Then, flow control statements and language structure statements are separated from the programming language commands, and statement identification information corresponding to the language structure statements is generated.

[0097] In one specific embodiment, the programming language commands in the source code file are first determined. Then, flow control statements (i.e., the PowerScript programming language mentioned above) and language structure statements (SQL statements) are separated from the programming language commands. Next, statement identification information of the structure statements is generated through the language structure statements. This statement identification information can be used to identify the language structure statements and flow control statements. For ease of understanding, an example is given below.

[0098] For example, below is the PowerScript and SQL code for a PowerBuilder application to insert a record into the Employee table in a database (EXECUTE IMMEDIATE is the PowerScript, and the following part is the SQL statement):

[0099] EXECUTE IMMEDIATE: "INSERT INTO Employee(code,name,sex)VALUES('C109','Xiao Ming','Male')"

[0100] The generated SQL file format is as follows, where 1001 is an automatically generated ID (i.e., statement identification information) used to uniquely identify the extracted SQL statement:

[0101] 1001 = "INSERT INTO Employee(code,name,sex)VALUES('C109','Xiaoming','Male')"

[0102] It should be noted that the above is only an explanation of flow control statements, language structure statements, and their statement identification information.

[0103] 302. Specify the statement identification information as the call identifier of the cloud server's network application interface, and generate a program language file based on the flow control statement, language structure statement, and statement identification information.

[0104] Then, the statement identification information is specified as the call identifier of the cloud server's network application interface, and a program language file is generated based on the flow control statement, language structure statement and statement identification information.

[0105] In one specific embodiment, the statement identification information is used as the designated call identifier for WebApi. Then, the separated flow control statements, language structure statements, and statement identification information are replaced to generate the final program language file. Specifically, the separation process also requires replacing the PowerScript and SQL code above with the following code, where WebApiClient is a WebApi client proxy encapsulation object used to send HTTP requests to call the cloud server's WebApi and execute the SQL command corresponding to the specified ID.

[0106] WebApiClient.ExecuteSqlWithID(1001)

[0107] Furthermore, the types of SQL commands vary greatly across different projects, and SQL commands may also have substitution parameters to replace user-input data. Specifically, by separating SQL commands from the source code and deploying them to the server, and then using a Web API client proxy to encapsulate objects for invocation, the security of database access can be ensured.

[0108] 303. If the client application file includes binary program files and dependency files, generate a dependency file between any two source code files.

[0109] Combination Figure 1 As shown, since there are multiple client application files, when the client application files include binary program files and dependency files, a dependency file between any two source code files can be generated first. It should be noted that the dependency file is used to represent the mutual calling relationship between any two source code files.

[0110] In one specific embodiment, if there are two source code files A and B, and there is a code calling relationship (dependency relationship) between these two source code files, then the dependent files between these two source code files can be determined first based on the calling relationship between them.

[0111] 304. Based on the dependency file, generate different binary program files corresponding to any two source code files.

[0112] Therefore, based on the dependency file, different binary program files corresponding to any two source code files can be generated.

[0113] In one specific embodiment, since typical C / S application projects are compiled from many source code files into a single binary program file (which can be recognized and executed by the machine), this file is usually quite large, making it difficult to download over the network. This embodiment uses a single source code file as the compilation target to reduce the size of the compiled file. Therefore, this process requires establishing a dependency file so that the client can download on demand. Specifically, as described in step 303 above, if source code files A and B generate a single binary program file, their mutual calls will not have problems due to the existence of a dependency file, and the operating system can automatically find the called module. However, after this process, the two files are compiled into two different binary program files, which the operating system may not be able to find because the called module may not have been downloaded from the cloud server. Therefore, the binary program file between source code files A and B can be compiled based on the dependency file. Then, the client application can download the specified binary program file according to the file dependency relationship. In other words, technically speaking, for a running program, A calls an object in B, but A is not actually aware that the object belongs to B. It only knows that the object belongs to B through association, thus downloading B (the binary program file). This association needs to be established during compilation and can be used during program execution.

[0114] It should also be noted that different programming languages ​​use different compilation tools. For example, PowerBuilder uses PBAutoBuild, while C++ may use LLVM. Therefore, this embodiment will not elaborate on the process of compiling source code files into binary program files.

[0115] 305. If the client application files include an executable file and a homepage file, compile the C / S application project based on the source code files to generate an executable file.

[0116] Corresponding to step 302, if the client application files at this point are an executable file and a homepage file, then the C / S application project can be compiled based on the source code files to generate an executable file. It should be noted that the executable file represents the program entry point of the client application.

[0117] In one specific embodiment, each C / S application project needs to be compiled to generate an executable file (EXE), which is the entry point of the application.

[0118] Furthermore, in a feasible technical solution, specifically in PowerBuilder it is compiled from the source code file Application, while in other languages ​​it may be compiled from the source code file containing the Main function.

[0119] 306. Generate the homepage file corresponding to the client application based on the resource file.

[0120] Simultaneously, step 306 can be executed concurrently with step 305. The execution order of steps 305 and 306 is not restricted here. Specifically, a homepage file corresponding to the client application can be generated based on the resource file. It should be noted that the homepage file is used to launch the executable file.

[0121] In one specific embodiment, each web application project needs to include a homepage file (index.html), which is the main page of the web application. In this embodiment, it is mainly responsible for launching the executable file (in the client application), as will be explained again during the running process.

[0122] 307. Generate an interface project based on the programming language file, compile the interface project to generate an interface service program file, and generate a network application interface based on the interface service program file; generate a backend service project based on the programming language file, compile the backend service project to generate a backend service program file, and generate a backend service program based on the backend service program file.

[0123] 308. Deploy the network application programming interface and backend service program on the application server of the cloud server; deploy the client application file on the network server of the cloud server.

[0124] In this embodiment, steps 307-308 are the same as those described above. Figure 2 Steps 204 and 205 are similar, and will not be elaborated here.

[0125] 309. Deploy the client service program file on the cloud server's network server, and deploy the client service program on the client according to the client service program file.

[0126] Furthermore, before step 310, i.e., before deploying the application database and the backend database, it is necessary to deploy the client service program file on the cloud server's web server, and then deploy the client service program on the client according to the client service program file. It should be noted that the client service program file is a program file used to provide services to the client's application, and the client service program is used to install the client's application.

[0127] In one specific embodiment, combined with Figure 1 As shown, the client service program file also needs to be deployed on the web server, and the relevant client service program file (used by users to download the application in their browser) needs to be deployed on the client (mainly the browser that the client can access; at this time, the browser can also be on the cloud server, and there is no restriction here).

[0128] Based on the steps outlined above, it can be understood that executable files, binary program files, and resource files are essential files for the client application, while the client service program file is the program file that needs to be installed on the client to provide services to the client application. This will be explained again during the runtime process. Specifically, this process can involve uploading and deploying these files to the web server via HTTP, FTP, or other file transfer tools.

[0129] 310. Deploy the application database and the backend database, bind the application database to the web application interface, and bind the backend database to the backend service program to complete the deployment of the C / S application project.

[0130] In this embodiment, step 310 is the same as described above. Figure 2 Step 206 is similar, and will not be elaborated here.

[0131] This embodiment discloses a C / S application deployment method. Because it adds a Web API service to the cloud server, allowing client applications to access the cloud application database, the security of the cloud application database is guaranteed. This is because the cloud application database only needs to expose its access port to the cloud; applications outside the cloud server are not allowed to access it. Furthermore, the Web API, as an intermediate service layer, effectively shields the cloud application database from external access. Simultaneously, this embodiment employs a standard three-tier architecture, resulting in low hardware requirements for software operation. Therefore, deploying applications using this solution does not incur high costs for enterprises. Moreover, this embodiment only requires implementing a single deployment process (which can be made into a tool) to publish existing C / S application projects or newly developed projects to the cloud without requiring developers to modify related program code, greatly improving project maintainability.

[0132] To facilitate Figure 1 For a detailed description of the cloud server shown, please refer to [link / reference]. Figure 4 , Figure 4 This is a flowchart illustrating a deployment method for a C / S application applied to a cloud server, as disclosed in an embodiment of this application. It includes steps 401-403.

[0133] 401. Receive the interface service program file sent by the development end, and deploy the generated network application interface on the application server based on the interface service program file; receive the background service program file sent by the development end, and deploy the generated background service program on the application server based on the background service program file.

[0134] It should be noted that this embodiment is primarily applied to cloud servers. (Combined with...) Figure 1 As shown, the cloud server has a communication connection with the development server. No restrictions are placed on the communication connection between the cloud server and the development server, and it will not be elaborated upon further. In this embodiment, the cloud server can receive the interface service program file sent by the development server and deploy the generated network application interface on the application server based on the interface service program file; it can also receive the background service program file sent by the development server and deploy the generated background service program on the application server based on the background service program file.

[0135] In one specific embodiment, combined with Figure 2 and Figure 3 As shown in step 204, the SQL file (programming language file) generated by the development team is required to be included in the Web API project. Therefore, the corresponding compilation tools need to be called to compile the SQL file into a Web API service program file. Specifically, the interface project (Web API project) is generated from the SQL file, and then the interface project is compiled to generate the interface service program file (Web API service program file). Finally, the development team can encapsulate the Web API service program file into a web application interface, i.e., a Web API interface, and deploy the Web API interface on the Application Server.

[0136] Additionally, the development team can generate a backend service project and compile it to generate backend service program files. Specifically, this process requires generating a backend service project, which is mainly used to manage client sessions, database connection configurations, and client requests. The design of these backend management functions will be explained again in the backend management section. Like Web APIs, the backend service project can be implemented using different programming languages, and then the corresponding compilation tools are used to compile it into backend service program files. In this embodiment, the backend service project is also generated from an SQL file, then compiled to generate the backend service program files. The development team can then distribute these backend service program files to the cloud server, generate the backend service program, and deploy the backend service program on the ApplicationServer.

[0137] 402. Receive the client application file sent by the development team and deploy the client application file on the network server.

[0138] Similar to step 401, the cloud server can also receive client application files from the development side and deploy the client application files on the web server.

[0139] In one specific embodiment, combined with Figure 2 and Figure 3 As shown, mainly Figure 2 Step 203 or Step 205, and Figure 3 In step 303 or step 305, the cloud server receives the client application files (executable file, binary program file, resource file, home page file, dependency file) from the development end and deploys them on the Web Server.

[0140] 403. Bind the application database to the network application interface and bind the backend database to the backend service program to complete the deployment of the C / S application project on the cloud server.

[0141] Therefore, the cloud server can bind the application database to the web application interface and the backend database to the backend service program, thus completing the deployment of C / S application projects on the cloud server. It should be noted that the application database is used by the client to access via the web application interface, while the backend database stores session information between the client and the cloud server.

[0142] In one specific embodiment, to enable interaction between the client and the cloud server, the cloud server may deploy an application database related to the Web API interface, as well as a backend database related to the background services of the client application.

[0143] The C / S application deployment method disclosed in this embodiment adds a Web API service to the cloud server. Client applications access the cloud application database through this service, so the security of the cloud application database can be guaranteed. This is because the cloud application database only needs to expose its access port to the cloud. Applications outside the cloud server are not allowed to access it. In addition, as an intermediate service layer, Web API can effectively shield the cloud application database from external information.

[0144] based on Figure 4 The illustrated embodiment can also execute [the following commands] after the cloud server is deployed. Figure 5 The illustrated embodiment. Please refer to [link / reference]. Figure 5 , Figure 5This is a flowchart illustrating another deployment method for a C / S application applied to a cloud server, as disclosed in an embodiment of this application. It includes steps 501-504.

[0145] 501. When the client application starts and the network server receives a session request, it calls the network application programming interface to create a session identifier.

[0146] It should be noted that since this embodiment mainly describes the interaction between the client and the cloud server, it will also provide a supplementary description of the client's operation process. This embodiment primarily focuses on the steps that the client and cloud server need to perform after deployment. Specifically, when the client's application starts and the network server receives a session request, it calls the network application programming interface (API) to create a session identifier. It should be noted that the session identifier is used for information exchange between the client's application and the network server.

[0147] In one specific embodiment, all requests in the web application are session-based. Once a session ends, requests cannot be sent and a new session needs to be established. In this embodiment, when the client application starts, it needs to call the Web API to create a session (SessionID) and store it in memory. Subsequent requests must include this session identifier.

[0148] 502. Store the session identifier and the corresponding user login information for the client in the backend database.

[0149] Then, the session identifier and the corresponding user login information for the client can be stored in the backend database.

[0150] In one specific embodiment, the SessionID and corresponding user login information (such as client IP, username, login time, etc.) can be stored in the background database. The system administrator can enter the background service management program to view session-related information, number of sessions, session runtime, configure session timeout, and terminate sessions.

[0151] For the client, combined Figure 1As shown, users need to enter a URL in their browser to access the application. Specifically, upon first accessing the application's homepage, a welcome page will be displayed, prompting the user to click a link to install the client service program (the browser can extract the client service program file deployed on the web server). The homepage and the client service program communicate via the HTTP protocol. Each time the user accesses the homepage, a detection request is sent to it; no response indicates that it is not installed, while a response proceeds to the next step of launching the client application. Additionally, the next step also occurs after the client service program is installed. It should be noted that the next step described in this embodiment is the invocation of the client service program to launch the client application.

[0152] 503. When the network server receives an access request, it retrieves the application connection object from the application database and configures the number of connection objects and the application connection parameters between each application connection object and the application database, so as to process the access request according to the configured application connection object.

[0153] Simultaneously with steps 501-502, when the network server receives an access request, it retrieves an application connection object from the application database and configures the number of connection objects and the application connection parameters between each application connection object and the application database, thereby processing the access request based on the configured application connection objects.

[0154] In one specific implementation, when the Web API receives a request to access the database, it retrieves a connection object (which can be understood as a wrapper object, for example, a Connection object provided by the ADO.NET driver) from the database connection cache—that is, the application connection object mentioned above—and then executes the corresponding request processing. The system administrator can configure the database connection parameters and the number of connection objects in the background service management program.

[0155] Furthermore, in this embodiment, the application connection parameters include, but are not limited to, host address, port number, database name, username, password, character set, and timeout. Correspondingly, the number of connection objects can be set to 100 or 200, etc., which will not be elaborated here.

[0156] Furthermore, in this embodiment, various requests sent by the client application are also recorded in the background database, facilitating log tracking by administrators. System administrators can access the background service management program to view relevant request logs, configure cleanup strategies, and manage request timeouts.

[0157] 504. When the client's local storage space meets the update trigger conditions, send the updated dependency files and the updated executable file to the client.

[0158] Simultaneously with steps 501-502, when the client's local storage space meets the update trigger conditions, the cloud server can send the updated dependency files and the updated executable files to the client.

[0159] In one specific embodiment, when the browser homepage sends an application launch request to the client service program on the client side, the client service program performs two tasks: First, it checks whether the client's local storage space contains dependency files, or whether the cloud server has updated them; both of these scenarios trigger the download and updating of local dependency files. Second, it checks whether the client's local storage space contains the application's executable file and whether the cloud server has updated it; both of these scenarios trigger the download and updating of the local executable file, and then executes the application launch. Consequently, the cloud server sends the updated dependency files and the updated executable file to the client service program, thus updating the dependency files and executable file on the client side.

[0160] Furthermore, in other feasible technical solutions, the browser calls the client-server program to launch the client application, after which the user can open the application modules. Specifically, after the client application starts, the user typically operates different business modules. For example, the user might open the employee management module from the main menu; however, this module may not exist locally. In this case, the application needs to instruct the client-server program to download the employee management module (binary program file) according to file dependencies. After the download is complete, the employee management module is opened. It should be noted that the above is only an analysis and description of one possible scenario; other feasible technical solutions will not be described in detail in this embodiment.

[0161] Furthermore, client applications can also access the application database and the backend database through the Application Server. Specifically, when a user performs a business operation in a certain module, they need to access data. For example, if a user wants to query all employee records in the employee management module, clicking the query button requires accessing the database. As can be seen from the deployment process above, when a user executes a query, an HTTP request with an ID (i.e., the SQL command corresponding to the specified ID described above, as described in step 302) is sent to the server to invoke the Web API to access the database, rather than the client application directly accessing the database.

[0162] This embodiment discloses a C / S application deployment method. The client application is launched via a URL, effectively improving its usability. A background service function is designed to enhance system integrity. Furthermore, the client application in this embodiment employs an on-demand file download scheme, significantly improving file download efficiency and user experience.

[0163] It should be understood that although the steps in the flowcharts of the embodiments described above are shown sequentially according to the arrows, these steps are not necessarily executed in the order indicated by the arrows. Unless explicitly stated herein, there is no strict order restriction on the execution of these steps, and they can be executed in other orders. Moreover, at least some steps in the flowcharts of the embodiments described above may include multiple steps or multiple stages. These steps or stages are not necessarily completed at the same time, but can be executed at different times. The execution order of these steps or stages is not necessarily sequential, but can be performed alternately or in turn with other steps or at least some of the steps or stages of other steps.

[0164] Please see Figure 6 , Figure 6 This is a schematic diagram of the structure of a C / S application deployment system disclosed in an embodiment of this application. It should be noted that... Figure 6 The deployment system shown in the embodiment is applied to the development side.

[0165] Acquisition unit 601 is used to acquire the source code files and resource files of the C / S application project.

[0166] The determining unit 602 is used to determine the programming language commands in the source code file and generate a programming language file based on the programming language commands;

[0167] The generation unit 603 is used to generate a client application file based on the source code file and resource file; wherein, the client application file is the application file of the client's application.

[0168] The generation unit 603 is also used to generate an interface project project based on the programming language file, compile the interface project project to generate an interface service program file, and generate a network application interface based on the interface service program file; generate a background service project project based on the programming language file, compile the background service project project to generate a background service program file, and generate a background service program based on the background service program file.

[0169] Deployment unit 604 is used to deploy network application interfaces and backend service programs on the application server of the cloud server; and to deploy client application files on the network server of the cloud server.

[0170] Deployment unit 604 is also used to deploy the application database and the backend database, and bind the application database to the network application interface and the backend database to the backend service program to complete the deployment of the C / S application project. The application database is used by the client to access the application through the network application interface, and the backend database is used to store the session information between the client and the cloud server.

[0171] For example, the system includes:

[0172] The generation unit 603 is specifically used to separate flow control statements and language structure statements in programming language commands, and generate statement identification information corresponding to the language structure statements;

[0173] The generation unit 603 is also used to specify the statement identification information as the call identifier of the network application interface of the cloud server, and to generate a program language file based on the flow control statement, the language structure statement and the statement identification information.

[0174] For example, if the client application file includes a binary program file and dependency files, the system includes:

[0175] The generation unit 603 is specifically used to generate a dependency relationship file between any two source code files; wherein, the dependency relationship file is used to represent the mutual calling relationship between any two source code files;

[0176] The generation unit 603 is also used to generate different binary program files corresponding to any two source code files according to the dependency file.

[0177] For example, if the client application files include an executable file and a homepage file, the system includes:

[0178] The generation unit 603 is specifically used to compile the C / S application project based on the source code file to generate an executable file; wherein, the executable file is used to represent the program entry point of the client application;

[0179] The generation unit 603 is also configured to generate a homepage file corresponding to the client's application based on the resource file; wherein the homepage file is used to launch the executable file.

[0180] For example, the system also includes:

[0181] Deployment unit 604 is also used to deploy the client service program file on the network server of the cloud server, and to deploy the client service program on the client according to the client service program file; wherein, the client service program file is a program file used to provide services for the client's application, and the client service program is used to install the client's application.

[0182] Please see Figure 7 , Figure 7 This is a schematic diagram of the structure of a C / S application deployment system disclosed in an embodiment of this application. It should be noted that... Figure 7 The deployment system shown in the embodiment is applied to a cloud server.

[0183] The receiving unit 701 is used to receive the interface service program file sent by the development end, and deploy the generated network application interface on the application server based on the interface service program file; and to receive the background service program file sent by the development end, and deploy the generated background service program on the application server based on the background service program file.

[0184] The receiving unit 701 is also used to receive the client application file sent by the development end and deploy the client application file on the network server;

[0185] Deployment unit 702 is used to bind the application database to the network application interface and the backend database to the backend service program to complete the deployment of the C / S application project on the cloud server; wherein, the application database is used by the client to access through the network application interface, and the backend database is used to store the session information between the client and the cloud server.

[0186] For example, the system further includes: a calling unit 703, a storage unit 704, and a retrieving unit 705;

[0187] Calling unit 703 is used to call the network application interface to create a session identifier when the client application starts and the network server receives a session request; the session identifier is used for information exchange between the client application and the network server.

[0188] Storage unit 704 is used to store the session identifier and the user login information corresponding to the client in the background database;

[0189] Alternatively, the acquisition unit 705 is used to retrieve application connection objects from the application database when the network server receives an access request, and configure the number of connection objects and the application connection parameters between each application connection object and the application database, so as to process the access request according to the configured application connection objects.

[0190] For example, the system further includes: a sending unit 706;

[0191] The sending unit 706 is used to send the updated dependency file and the updated executable file to the client when the client's local storage space meets the update triggering conditions. The update triggering conditions include the client's local storage space not containing the updated dependency file and the updated executable file, or the cloud server receiving one or more of the updated dependency file and the updated executable file from the development end. The dependency file is used to represent the mutual calling relationship between any two source codes in the C / S application project, and the executable file is used to represent the program entry point of the client's application.

[0192] Please refer to the following: Figure 8 The schematic diagram of a C / S application deployment device disclosed in this application includes:

[0193] Central processing unit 801, memory 805, input / output interface 804, wired or wireless network interface 803, and power supply 802;

[0194] Memory 805 is either a short-term storage memory or a persistent storage memory;

[0195] The central processing unit 801 is configured to communicate with the memory 805 and execute instructions stored in the memory 805 to perform the aforementioned operations. Figures 2 to 5 Deployment method of C / S application in any of the illustrated embodiments.

[0196] This application also provides a chip system, which includes at least one processor and a communication interface. The communication interface and the at least one processor are interconnected via a circuit. The at least one processor is used to run computer programs or instructions to perform the aforementioned... Figures 2 to 5 The deployment method of the C / S application in the illustrated embodiment.

[0197] This application also provides a computer-readable storage medium, which includes instructions that, when executed on a computer, cause the computer to perform the aforementioned actions. Figures 2 to 5 The deployment method of the C / S application in the illustrated embodiment.

[0198] This application also provides a computer program product containing instructions, which, when run on a computer, causes the computer to perform the aforementioned... Figures 2 to 5 The deployment method of the C / S application in the illustrated embodiment.

[0199] Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the specific working processes of the systems, devices, and units described above can be referred to the corresponding processes in the foregoing method embodiments, and will not be repeated here.

[0200] In the several embodiments provided in this application, it should be understood that the disclosed systems, apparatuses, and methods can be implemented in other ways. For example, the apparatus embodiments described above are merely illustrative; for instance, the division of units is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the coupling or direct coupling or communication connection shown or discussed may be an indirect coupling or communication connection between apparatuses or units through some interfaces, and may be electrical, mechanical, or other forms.

[0201] The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the units can be selected to achieve the purpose of this embodiment according to actual needs.

[0202] Furthermore, the functional units in the various embodiments of this application can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The integrated unit can be implemented in hardware or as a software functional unit.

[0203] If the integrated unit is implemented as a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, or all or part of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods described in the various embodiments of this application. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

Claims

1. A method for deploying a C / S application, characterized in that, When applied to the development side, the method includes: Obtain the source code and resource files of the C / S application project; The programming language commands are determined in the source code file, and a programming language file is generated based on the programming language commands; A client application file is generated based on the source code file and the resource file; wherein, the client application file is the application file of the client's application. An interface project is generated based on the programming language file, and the interface project is compiled to generate an interface service program file, which is then used to generate a network application interface; a background service project is generated based on the programming language file, and the background service project is compiled to generate a background service program file, which is then used to generate a background service program. The network application interface and the background service program are deployed on the application server of the cloud server; the client application file is deployed on the network server of the cloud server. Deploy an application database and a backend database, and bind the application database to the network application interface and the backend database to the backend service program to complete the deployment of the C / S application project; wherein, the application database is used by the client to access through the network application interface, and the backend database is used to store the session information between the client and the cloud server; The process of generating a program language file based on the program language commands includes: Separate flow control statements and language structure statements from the programming language commands, and generate statement identification information corresponding to the language structure statements; The statement identification information is designated as the call identifier of the network application interface of the cloud server, and the program language file is generated according to the flow control statement, the language structure statement and the statement identification information; If the client application file includes a binary program file and a dependency file, generating the client application file based on the source code file and the resource file includes: Generate a dependency file between any two source code files; wherein the dependency file is used to characterize the mutual calling relationship between the two source code files; Based on the dependency file, generate different binary program files corresponding to any two source code files.

2. The deployment method for a C / S application according to claim 1, characterized in that, If the client application file includes an executable file and a homepage file, generating the client application file based on the source code file and the resource file includes: The C / S application project is compiled based on the source code file to generate the executable file; wherein, the executable file is used to represent the program entry point of the client application; A homepage file corresponding to the application of the client is generated based on the resource file; wherein, the homepage file is used to launch the executable file.

3. The deployment method for a C / S application according to claim 1, characterized in that, Before deploying the application database and the backend database, the method further includes: The client service program file is deployed on the network server of the cloud server, and the client service program is deployed on the client according to the client service program file; wherein, the client service program file is a program file used to provide services for the client's application, and the client service program is used to install the client's application.

4. A method for deploying a C / S application, characterized in that, Applied to a cloud server, wherein the cloud server includes a network server and an application server, the method includes: The system receives an interface service program file from the development end and deploys the generated network application interface on the application server based on the interface service program file; it also receives a background service program file from the development end and deploys the generated background service program on the application server based on the background service program file; wherein the interface service program file and the background service program file are generated by the C / S application deployment method according to claim 1. The system receives a client application file from the development terminal and deploys the client application file on the network server; wherein the client application file is generated by the C / S application deployment method described in claim 1. The application database is bound to the network application interface, and the backend database is bound to the backend service program to complete the deployment of the C / S application project on the cloud server; wherein, the application database is used by the client to access through the network application interface, and the backend database is used to store the session information between the client and the cloud server; wherein, the application database and the backend database are deployed by the C / S application deployment method of claim 1.

5. The deployment method for a C / S application according to claim 4, characterized in that, The method further includes: When the client application starts and the network server receives a session request, it calls the network application interface to create a session identifier; wherein, the session identifier is used for information interaction between the client application and the network server; The session identifier and the user login information corresponding to the client are stored in the background database; Alternatively, when the network server receives an access request, it retrieves an application connection object from the application database and configures the number of connection objects for each application connection object and the application connection parameters between each application connection object and the application database, so as to process the access request according to the configured application connection objects.

6. The deployment method for a C / S application according to claim 4, characterized in that, The method further includes: When the client's local storage space meets the update triggering conditions, the updated dependency file and the updated executable file are sent to the client; wherein, the update triggering conditions include the client's local storage space not containing the updated dependency file and the updated executable file, or the cloud server receiving one or more of the updated dependency file and the updated executable file sent by the development end; the dependency file is used to represent the mutual calling relationship between any two source codes of the C / S application project, and the executable file is used to represent the program entry point of the client's application.

7. A deployment system for a client / server application, characterized in that, The system, applied to the development side, includes: The acquisition unit is used to acquire the source code files and resource files of the C / S application project. A determining unit is used to determine programming language commands in the source code file and generate a programming language file based on the programming language commands; A generation unit is configured to generate a client application file based on the source code file and the resource file; wherein the client application file is the application file of the client's application. The generation unit is further configured to generate an interface project based on the programming language file, compile the interface project to generate an interface service program file, and generate a network application interface based on the interface service program file; generate a background service project based on the programming language file, compile the background service project to generate a background service program file, and generate a background service program based on the background service program file. The deployment unit is used to deploy the network application interface and the background service program on the application server of the cloud server; and to deploy the client application file on the network server of the cloud server. The deployment unit is further configured to deploy an application database and a backend database, and bind the application database to the network application interface and the backend database to the backend service program to complete the deployment of the C / S application project; wherein, the application database is used by the client to access through the network application interface, and the backend database is used to store session information between the client and the cloud server; The system includes: The generation unit is specifically used to separate flow control statements and language structure statements from the programming language commands, and generate statement identification information corresponding to the language structure statements; The generation unit is further configured to designate the statement identification information as the call identifier of the network application interface of the cloud server, and generate the program language file according to the flow control statement, the language structure statement and the statement identification information; If the client application file includes a binary program file and dependency files, the system includes: The generation unit is specifically used to generate a dependency relationship file between any two source code files; wherein, the dependency relationship file is used to characterize the mutual calling relationship between the any two source code files; The generation unit is also configured to generate different binary program files corresponding to any two source code files, based on the dependency relationship file.

8. A deployment system for a client / server application, characterized in that, Applied to cloud servers, the cloud servers including network servers and application servers, the system includes: A receiving unit is configured to receive an interface service program file sent by the development end, and deploy the generated network application interface on the application server based on the interface service program file; receive a background service program file sent by the development end, and deploy the generated background service program on the application server based on the background service program file; wherein, the interface service program file and the background service program file are generated by the C / S application deployment method according to claim 1; The receiving unit is further configured to receive the client application file sent by the development end and deploy the client application file on the network server; wherein the client application file is generated by the C / S application deployment method according to claim 1; The deployment unit is used to bind the application database to the network application interface and the backend database to the backend service program to complete the deployment of the C / S application project on the cloud server; wherein, the application database is used by the client to access through the network application interface, and the backend database is used to store the session information between the client and the cloud server.

9. A deployment device for a C / S application, characterized in that, The device includes: Central processing unit, memory, input / output interfaces, wired or wireless network interfaces, and power supply; The memory is either a short-term storage memory or a persistent storage memory; The central processing unit is configured to communicate with the memory and execute instructions in the memory to perform the deployment method of the C / S application according to any one of claims 1 to 6.

10. A computer-readable storage medium, characterized in that, The computer-readable storage medium includes instructions that, when executed on a computer, cause the computer to perform the deployment method of a C / S application as described in any one of claims 1 to 6.

Images