CN110413920A - Method and device for generating pages - Google Patents

Abstract

The embodiment of the present application discloses a method and device for generating a page. A specific implementation of the above method includes: receiving and parsing the data sent by the server, the data includes the view object identifier and the data to be displayed; creating a model object according to the view object identifier, the preset first mapping list and the data to be displayed, wherein , the first mapping list includes the view object identifier and the model object identifier corresponding to the view object identifier, and the model object name; create a view object according to the created model object and the preset second mapping list, wherein the second mapping list includes the model The object identifier and the name of the view object corresponding to the model object identifier; layout the created view object and generate a page. This embodiment improves the page generation speed and avoids the jamming phenomenon when generating pages or refreshing pages.

Description

Method and device for generating pages

technical field

The embodiment of the present application relates to the technical field of the Internet, and in particular to a method and an apparatus for generating a page.

Background technique

Currently, page development generally uses the MVC (Model-View-Controller, Model-View-Controller) design pattern, where M refers to the data model, V refers to the user interface, and C refers to the controller. Using MVC is to separate the data model and user interface code, so that the same program can use different forms of expression. For example, a batch of statistical data can be represented by histograms and pie charts. The purpose of the controller is to ensure the synchronization of the data model and the user interface. Once the data model changes, the user interface should be updated synchronously.

Contents of the invention

The embodiment of the present application proposes a method and an apparatus for generating a page.

In the first aspect, the embodiment of the present application provides a method for generating a page, including: receiving and analyzing the data sent by the server, the above-mentioned data includes the view object identifier and the data to be displayed; according to the above-mentioned view object identifier, preset The first mapping list and the above-mentioned data to be displayed create a model object, wherein the above-mentioned first mapping list includes a view object identifier and a model object identifier corresponding to the view object identifier, and a model object name; according to the created model object and the preset first The second mapping list is to create a view object, wherein the second mapping list includes a model object identifier and a view object name corresponding to the model object identifier; layout the created view object to generate a page.

In some embodiments, the creation of the model object according to the view object identifier, the preset first mapping list, and the data to be displayed includes: determining the model object identifier corresponding to the view object identifier according to the preset first mapping list and the model object name; according to the determined model object name, call a preset object generation function to generate an object; encapsulate the determined model object identifier and the above-mentioned data to be displayed in the generated object to obtain a model object.

In some embodiments, the creation of the view object based on the created model object and the preset second mapping list includes: parsing the created model object to obtain the model object identifier; The name of the view object corresponding to the model object identifier; according to the determined name of the view object, call the preset object generation function to generate the view object.

In some embodiments, before receiving and parsing the data returned by the server, the method further includes: sending a data acquisition request to the server in response to detecting a user-triggered page generation operation.

In some embodiments, the above method further includes: in response to detecting the view switching operation triggered by the user, calling a layout function corresponding to the above view switching operation to change the layout of the created view object; The layout of the page to get the switching view.

In the second aspect, the embodiment of the present application provides a device for generating a page, including: a data receiving unit configured to receive and analyze the data sent by the server, the above data includes the view object identifier and the data to be displayed; the model object The creating unit is configured to create a model object according to the view object identifier, the preset first mapping list, and the data to be displayed, wherein the first mapping list includes the view object identifier and the model object identifier corresponding to the view object identifier, Model object name; a view object creation unit configured to create a view object according to the created model object and a preset second mapping list, wherein the second mapping list includes a model object identifier and a view object corresponding to the model object identifier Name; page generation unit, configured to lay out the created view objects and generate pages.

In some embodiments, the model object creation unit is further configured to: determine the model object identifier and the model object name corresponding to the view object identifier according to the preset first mapping list; call the preset model object name according to the determined model object name. The object generation function is set to generate the object; the determined model object identifier and the above data to be displayed are encapsulated in the generated object to obtain the model object.

In some embodiments, the view object creating unit is further configured to: parse the created model object to obtain the model object identifier; determine the name of the view object corresponding to the parsed model object identifier according to the second mapping list; With the determined view object name, call the preset object generation function to generate the view object.

In some embodiments, the above-mentioned device further includes: a request sending unit configured to send a data acquisition request to the server in response to detecting a user-triggered page generation operation before the data receiving unit receives and parses the data returned by the server. ask.

In some embodiments, the above-mentioned apparatus further includes a view switching unit configured to: in response to detecting a user-triggered view switching operation, call a layout function corresponding to the above-mentioned view switching operation to change the layout of the created view object; The layout of the created view object is changed, and the page for switching views is obtained.

In a third aspect, the embodiment of the present application provides a terminal, including: one or more processors; a storage device for storing one or more programs, when the above one or more programs are executed by the above one or more processors Executing, so that the above one or more processors implement the method described in any one of the above embodiments.

In a fourth aspect, the embodiments of the present application provide a computer-readable medium, on which a computer program is stored, and when the program is executed by a processor, the method described in any one of the above-mentioned embodiments is implemented.

The method and device for generating pages provided by the above-mentioned embodiments of the present application first receive and parse the data sent by the server, the above-mentioned data includes the view object identifier and the data to be displayed, and then according to the above-mentioned view object identifier and the preset first Create a model object for the mapping list and the above-mentioned data to be displayed, and then create a view object according to the created model object and the preset second mapping list, and finally layout the created view object to generate a page. With the method and device of this embodiment, when the data sent by the server is updated data, a view object can be generated according to the updated data, and then a new page can be generated according to the generated view object, thereby improving the page generation speed and avoiding Fixed the lag when generating or refreshing the page.

Description of drawings

Other characteristics, objects and advantages of the present application will become more apparent by reading the detailed description of non-limiting embodiments made with reference to the following drawings:

FIG. 1 is an exemplary system architecture diagram to which the present application can be applied;

FIG. 2 is a flowchart of an embodiment of a method for generating a page according to the present application;

FIG. 3 is a schematic diagram of an application scenario of a method for generating a page according to the present application;

Fig. 4 is a schematic structural diagram of an embodiment of a device for generating a page according to the present application;

Fig. 5 is a schematic structural diagram of a computer system suitable for implementing a terminal device according to an embodiment of the present application.

Detailed ways

The application will be further described in detail below in conjunction with the accompanying drawings and embodiments. It should be understood that the specific embodiments described here are only used to explain related inventions, rather than to limit the invention. It should also be noted that, for the convenience of description, only the parts related to the related invention are shown in the drawings.

It should be noted that, in the case of no conflict, the embodiments in the present application and the features in the embodiments can be combined with each other. The present application will be described in detail below with reference to the accompanying drawings and embodiments.

FIG. 1 shows an exemplary system architecture 100 to which embodiments of the method for generating a page or the apparatus for generating a page of the present application can be applied.

As shown in FIG. 1 , a system architecture 100 may include terminal devices 101 , 102 , 103 , a network 104 and a server 105 . The network 104 is used as a medium for providing communication links between the terminal devices 101 , 102 , 103 and the server 105 . Network 104 may include various connection types, such as wires, wireless communication links, or fiber optic cables, among others.

Users can use terminal devices 101 , 102 , 103 to interact with server 105 via network 104 to receive or send data and the like. Various communication client applications can be installed on the terminal devices 101, 102, 103, such as web browser applications, shopping applications, search applications, instant messaging tools, email clients, social platform software, and the like.

The hardware of the terminal devices 101, 102, and 103 may also be software. When the terminal devices 101, 102, 103 are hardware, they can be various electronic devices with display screens and supporting web browsing, including but not limited to smartphones, tablet computers, e-book readers, MP3 players (Moving Picture Experts Group Audio Layer III, moving picture expert compression standard audio layer 3), MP4 (Moving Picture Experts Group Audio Layer IV, moving picture expert compression standard audio layer 4) player, laptop portable computer and desktop computer, etc. When the terminal devices 101, 102, 103 are software, they can be installed in the electronic devices listed above. It can be implemented as a plurality of software or software modules (for example, to provide distributed services), or as a single software or software module. No specific limitation is made here.

The server 105 may be a server that provides various services, for example, a background web server that provides support for web pages displayed on the terminal devices 101 , 102 , and 103 . The background web server can analyze and process the received data such as the data acquisition request, and feed back the processing result (such as the data to be displayed and the view object identifier) to the terminal device.

It should be noted that the methods for generating pages provided by the embodiments of the present application are generally executed by terminal devices 101 , 102 , and 103 , and correspondingly, the means for generating pages are generally set in terminal devices 101 , 102 , and 103 .

It should be noted that the server may be hardware or software. When the server is hardware, it can be implemented as a distributed server cluster composed of multiple servers, or as a single server. When the server is software, it can be implemented as multiple software or software modules (for example, for providing distributed services), or as a single software or software module. No specific limitation is made here.

It should be understood that the numbers of terminal devices, networks and servers in Fig. 1 are only illustrative. According to the implementation needs, there can be any number of terminal devices, networks and servers.

Continue referring to FIG. 2 , which shows a flow 200 of an embodiment of the method for generating a page according to the present application. The method for generating a page in this embodiment includes the following steps:

Step 201, receiving and parsing the data sent by the server.

In this embodiment, the execution subject on which the method for generating the page runs (for example, the terminal device shown in FIG. 1 ) can receive data from the server through a wired connection or a wireless connection. The execution subject may receive the above-mentioned data when the data stored in the server is updated, or may receive the above-mentioned data after sending a data request to the server. After the execution subject receives the data sent by the server, it can analyze the above data.

In the design pattern of MVC, the data of the application is encapsulated by creating model objects in the model (Model), the data of the application is displayed by creating view objects in the view (View), and the data of the application is displayed in the controller (Controller) through the controller object. Acts as an intermediary between model objects and view objects, for example, view objects learn about changes to model objects through controller objects. The model is responsible for interacting with the server to access data on the server. In this embodiment, the above data may include a view object identifier and data to be displayed. The view object identifier is the identifier of the view object created by the view (View), and the above identifier can be a number or a character string. The above-mentioned data to be displayed is the data in the application program, for example, the above-mentioned data to be displayed may be contact information in the address book, or product information in the application program. In some implementation manners, the data from the server may include a view object identifier list, and the view object identifier list includes multiple view object identifiers.

It should be pointed out that the above wireless connection methods may include but not limited to 3G/4G connection, WiFi connection, Bluetooth connection, WiMAX connection, Zigbee connection, UWB (ultra wideband) connection, and other wireless connection methods known or developed in the future .

Step 202, create a model object according to the view object identifier, the preset first mapping list and the data to be displayed.

After obtaining the above data, the execution subject can create a model object according to the above view object identifier, the preset first mapping list and the above data to be displayed. The above-mentioned first mapping list includes the view object identifier and the model object identifier and model object name corresponding to the view object identifier. The model object identifier is the identification information of the model object created by the model (Model), and the model object name is the name of the above-mentioned model object.

In this embodiment, a view object identifier corresponds to a model object identifier, and also corresponds to a model object name. The model object ID can be the same as the view object ID, for example, both the model object ID and the view object ID are represented by numbers, and the value of the model object ID is equal to the value of the view object ID. The model object identifier may be different from the view object identifier, for example, the model object identifier is A11, and the corresponding view object identifier is B12. Model object names can be represented as strings. The execution subject can create the object according to the preset template and the name of the model object, and then encapsulate the determined model object identifier and the data to be displayed in the created object to obtain the model object.

It can be understood that, when the data from the server includes multiple view identifiers, correspondingly, the execution subject will create multiple model objects.

In some optional implementations of this embodiment, the above step 202 can be specifically implemented through the following steps not shown in FIG. 2: first, according to the preset first mapping list, determine the model corresponding to the view object identifier Object ID and model object name. Then, according to the determined name of the model object, a preset object generation function is invoked to generate the object. Finally, the determined model object identifier and the data to be displayed are encapsulated in the generated object to obtain the model object.

In this implementation, the execution subject may first look up the view object identifier in the first mapping list, and then determine the model object identifier and model object name corresponding to the view object identifier. Then, according to the determined name of the model object, a preset object generation function is invoked to generate the object. The above-mentioned object generation function may be NSClassFormString, which is a function for creating classes and objects in the iOS system. By calling this function, the execution subject can create an object according to the model object name. Then encapsulate the determined model object identifier and the above-mentioned data to be displayed in the generated object to obtain a model object.

It should be noted that when there are multiple model objects created by the execution subject, the created objects can be added to an array to obtain an array of model objects.

Step 203, create a view object according to the created model object and the preset second mapping list.

After the model object is created, the execution subject can combine the preset second mapping list to create the view object. The above-mentioned second mapping list may include a model object identifier and a view object name corresponding to the model object identifier. For example, the above-mentioned second mapping list may include a plurality of key-value pairs (key-value), the key value represents the identifier of the model object, and the value value may be the name of the view object. After the execution subject creates the model object, it can determine the name of the view object according to the model object identifier in the model object and the above-mentioned second mapping list, and then create the view object.

In some optional implementation manners of this embodiment, the above step 203 may specifically be implemented through the following steps not shown in FIG. 2 : first, parse the created model object to obtain the model object identifier. Then, according to the second mapping list, determine the view object name corresponding to the parsed model object identifier. Finally, according to the determined name of the view object, a preset object generating function is invoked to generate the view object.

In this implementation manner, the execution subject may first parse the created model object to obtain the model object identifier. Then, according to the second mapping list, determine the name of the view object corresponding to the model object identifier. Finally, according to the name of the above view object, call the object generation function to generate the view object. The above object generation function may be NSClassFormString. The generated view objects can display data from the model objects.

It should be noted that when the execution subject creates multiple model objects, before creating the view object, an array can be created first, and then the created view object can be added to the above array.

Step 204, layout the created view objects to generate a page.

After the execution subject creates the view object, it can lay out the above view object and generate a page. The layout of the view objects may include adjusting the height occupied by each view object on the page, and adjusting the way of pictures or text displayed in the view objects (for example, pictures are displayed on the left and text is displayed on the right).

When the execution subject executes the method of this embodiment, for an application program, multiple threads may be run to execute the above steps, for example, the controller, the model and the view run in different threads respectively. In addition, in this embodiment, a model management module and a view management module can be added in the MVC design mode. Similarly, the above-mentioned model management module and view management module run in different threads respectively.

The above-mentioned model management module can read the first mapping list, and then combine the view object identifier from the server to determine the model object identifier and model object name, and then the model creates a model object according to the above-mentioned model object identifier, model object name and data to be displayed. In some implementation manners, the above-mentioned model management module can create an array, and the model can add the created model objects to the above-mentioned array.

The above-mentioned view management module can obtain and parse the model object created by the model to obtain the model object identifier, and then read the second mapping list to obtain the view object name. The view creates a view object based on the obtained view object name. In some implementation manners, the view management module may create an array, and the view may add the created view objects to the above array.

Continuing to refer to FIG. 3 , FIG. 3 is a schematic diagram of an application scenario of the method for generating a page according to this embodiment. In the application scenario of FIG. 3 , the server 301 sends data to the terminal 302 , and the terminal parses to obtain the view object identifier after receiving the above data. Then, combine the first mapping list to obtain the model object identifier and the model object name. Next, create the model object. Then parse the model object to obtain the model object identifier, combine with the second mapping list to obtain the view object name. Then the view object is created, and finally the created object is laid out, and finally the page shown in 3021 displayed on the terminal 302 is obtained.

The method for generating a page provided by the above-mentioned embodiments of the present application first receives and parses the data sent by the server, the above-mentioned data includes the view object identifier and the data to be displayed, and then according to the above-mentioned view object identifier and the preset first mapping list And the above data to be displayed, create a model object, then create a view object according to the created model object and the preset second mapping list, and finally layout the created view object to generate a page. With the method of this embodiment, when the data sent by the server is updated data, a view object can be generated according to the updated data, and then a new page can be generated according to the generated view object, thereby improving the page generation speed and avoiding the need to generate Stuck phenomenon when the page or page is refreshed.

In some optional implementations of this embodiment, before step 201, the above method may further include the following steps not shown in FIG. ask.

In this implementation, when the execution subject is a terminal, the terminal can detect user operations, and when detecting a user-triggered page generation operation, can send a data acquisition request to the server. The above-mentioned page generation operation may include a user's refresh operation on a generated page, a click operation on a page generation application installed in a terminal, and the like. The above refresh operation may include sliding down the page, clicking a refresh button, etc., and the above click operation may include a single click operation, double click operation, etc. for generating an application icon on the page.

In some optional implementations of this embodiment, the above method may further include the following steps not shown in FIG. 2: first, in response to detecting a view switching operation triggered by the user, calling a layout function corresponding to the view switching operation to change the layout of the created view object. Then, according to the changed layout of the created view object, the page for switching views is obtained.

In this implementation manner, the execution subject may be a terminal device, which may detect a user's view switching operation. The foregoing view switching operation may be a user's clicking operation on a view switching button, or a sliding operation on a page, and the like. After the execution subject detects the above view switching operation, it can call the layout function corresponding to the view switching operation to change the layout of the created view object. Then according to the changed layout, the page for switching views is obtained. For example, the user can switch from the large picture mode to the detailed list mode by clicking the view switching button on the page.

Further referring to FIG. 4 , as an implementation of the methods shown in the above figures, the present application provides an embodiment of a device for generating pages, which corresponds to the method embodiment shown in FIG. 2 . The device can be specifically applied to various electronic devices.

As shown in FIG. 4 , the apparatus 400 for generating a page in this embodiment includes: a data receiving unit 401 , a model object creating unit 402 , a view object creating unit 403 and a page generating unit 404 .

Wherein, the data receiving unit 401 is configured to receive and analyze the data sent by the server, the above data includes the view object identifier and the data to be displayed.

The model object creating unit 402 is configured to create a model object according to the view object identifier, the preset first mapping list and the data to be displayed.

Wherein, the first mapping list includes a view object identifier, a model object identifier corresponding to the view object identifier, and a model object name.

The view object creating unit 403 is configured to create a view object according to the created model object and the preset second mapping list.

Wherein, the second mapping list includes the model object identifier and the view object name corresponding to the model object identifier.

The page generation unit 404 is configured to lay out the created view objects to generate a page.

In some optional implementations of this embodiment, the model object creation unit 402 may be further configured to: determine the model object identifier and the model object name corresponding to the view object identifier according to the preset first mapping list; The determined model object name is invoked to generate an object by calling a preset object generation function; the determined model object identifier and the data to be displayed are encapsulated in the generated object to obtain a model object.

In some optional implementations of this embodiment, the view object creating unit 403 may be further configured to: parse the created model object to obtain the model object identifier; determine the parsed model object identifier according to the second mapping list The corresponding view object name; according to the determined view object name, call a preset object generation function to generate a view object.

In some optional implementations of this embodiment, the above device may further include a request sending unit not shown in FIG. 4, configured to respond to the detection of To the page generation operation triggered by the user, send a data acquisition request to the server.

In some optional implementations of this embodiment, the above-mentioned apparatus may further include a view switching unit not shown in FIG. 4, configured to: respond to detecting a view switching operation triggered by the user, call the above-mentioned view switching Operate the corresponding layout function to change the layout of the created view object; according to the changed layout of the created view object, the page for switching views is obtained.

The device for generating a page provided by the above-mentioned embodiments of the present application first receives and parses the data sent by the server, the above-mentioned data includes the view object identifier and the data to be displayed, and then according to the above-mentioned view object identifier and the preset first mapping list And the above data to be displayed, create a model object, then create a view object according to the created model object and the preset second mapping list, and finally layout the created view object to generate a page. The device of this embodiment, when the data sent by the server is updated data, can generate a view object according to the updated data, and then generate a new page according to the generated view object, thereby improving the generation speed of the page and avoiding the need to generate Stuck phenomenon when the page or page is refreshed.

It should be understood that the units 401 to 404 described in the apparatus 400 for generating a page respectively correspond to the steps in the method described with reference to FIG. 2 . Therefore, the operations and features described above for the method for generating a page are also applicable to the device 400 and the units contained therein, and will not be repeated here.

Referring now to FIG. 5 , it shows a schematic structural diagram of a computer system 500 suitable for implementing a terminal device according to an embodiment of the present application. The terminal device shown in FIG. 5 is only an example, and should not limit the functions and scope of use of this embodiment of the present application.

As shown in FIG. 5 , a computer system 500 includes a central processing unit (CPU) 501 that can be programmed according to a program stored in a read-only memory (ROM) 502 or a program loaded from a storage section 508 into a random-access memory (RAM) 503 Instead, various appropriate actions and processes are performed. In the RAM 503, various programs and data necessary for the operation of the system 500 are also stored. The CPU 501 , ROM 502 , and RAM 503 are connected to each other through a bus 504 . An input/output (I/O) interface 505 is also connected to the bus 504 .

The following components are connected to the I/O interface 505: an input section 506 including a keyboard, a mouse, etc.; an output section 507 including a cathode ray tube (CRT), a liquid crystal display (LCD), etc., and a speaker; a storage section 508 including a hard disk, etc. and a communication section 509 including a network interface card such as a LAN card, a modem, or the like. The communication section 509 performs communication processing via a network such as the Internet. A drive 510 is also connected to the I/O interface 505 as needed. A removable medium 511, such as a magnetic disk, an optical disk, a magneto-optical disk, a semiconductor memory, etc., is mounted on the drive 510 as necessary so that a computer program read therefrom is installed into the storage section 508 as necessary.

In particular, according to an embodiment of the present disclosure, the processes described above with reference to the flowcharts can be implemented as computer software programs. For example, the embodiments of the present disclosure include a computer program product including a computer program carried on a machine-readable medium, the computer program including program code for executing the method shown in the flowchart. In such an embodiment, the computer program may be downloaded and installed from a network via communication portion 509 and/or installed from removable media 511 . When the computer program is executed by the central processing unit (CPU) 501, the above-mentioned functions defined in the method of the present application are performed.

It should be noted that the computer-readable medium described in this application may be a computer-readable signal medium or a computer-readable storage medium or any combination of the above two. A computer readable storage medium may be, for example, but not limited to, an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination thereof. More specific examples of computer-readable storage media may include, but are not limited to, electrical connections with one or more wires, portable computer diskettes, hard disks, random access memory (RAM), read-only memory (ROM), erasable Programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage device, magnetic storage device, or any suitable combination of the above. In the present application, a computer-readable storage medium may be any tangible medium that contains or stores a program that can be used by or in conjunction with an instruction execution system, apparatus, or device. In this application, however, a computer-readable signal medium may include a data signal propagated in baseband or as part of a carrier wave, in which computer-readable program codes are carried. Such propagated data signals may take many forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination of the foregoing. A computer-readable signal medium may also be any computer-readable medium other than a computer-readable storage medium, which can send, propagate, or transmit a program for use by or in conjunction with an instruction execution system, apparatus, or device. . Program code embodied on a computer readable medium may be transmitted using any appropriate medium, including but not limited to wireless, wireline, optical fiber cable, RF, etc., or any suitable combination of the foregoing.

Computer program code for performing the operations of the present application may be written in one or more programming languages or combinations thereof, including object-oriented programming languages—such as Java, Smalltalk, C++, and conventional Procedural Programming Language - such as "C" or a similar programming language. The program code may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. In cases involving a remote computer, the remote computer can be connected to the user computer through any kind of network, including a local area network (LAN) or a wide area network (WAN), or it can be connected to an external computer (such as through an Internet service provider). Internet connection).

The flowchart and block diagrams in the Figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present application. In this regard, each block in a flowchart or block diagram may represent a module, program segment, or portion of code that contains one or more logical functions for implementing specified executable instructions. It should also be noted that, in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or they may sometimes be executed in the reverse order, depending upon the functionality involved. It should also be noted that each block of the block diagrams and/or flowchart illustrations, and combinations of blocks in the block diagrams and/or flowchart illustrations, can be implemented by a dedicated hardware-based system that performs the specified functions or operations , or may be implemented by a combination of dedicated hardware and computer instructions.

The units involved in the embodiments described in the present application may be implemented by means of software or by means of hardware. The described units can also be set in a processor, for example, it can be described as: a processor includes a data receiving unit, a model object creating unit, a view object creating unit and a page generating unit. Wherein, the names of these units do not limit the unit itself under certain circumstances, for example, the data receiving unit may also be described as "a unit that receives and parses data sent by the server".

As another aspect, the present application also provides a computer-readable medium. The computer-readable medium may be included in the device described in the above embodiments, or it may exist independently without being assembled into the device. The computer-readable medium carries one or more programs, and when the one or more programs are executed by the device, the device: receives and parses the data sent by the server, the data includes the view object identifier and the data to be displayed; Create a model object according to the above-mentioned view object identifier, the preset first mapping list and the above-mentioned data to be displayed, wherein the above-mentioned first mapping list includes the view object identifier and the model object identifier and model object name corresponding to the view object identifier; according to the The created model object and the preset second mapping list are used to create a view object, wherein the second mapping list includes the model object identifier and the view object name corresponding to the model object identifier; the created view object is laid out to generate a page.

The above description is only a preferred embodiment of the present application and an illustration of the applied technical principles. Those skilled in the art should understand that the scope of the invention involved in this application is not limited to the technical solution formed by the specific combination of the above-mentioned technical features, and should also cover the technical solutions formed by the above-mentioned technical features or without departing from the above-mentioned inventive concept. Other technical solutions formed by any combination of equivalent features. For example, a technical solution formed by replacing the above-mentioned features with technical features with similar functions disclosed in (but not limited to) this application.

Claims (12)

1. A method for generating a page comprising: Receive and parse the data sent by the server, the data includes the view object identifier and the data to be displayed; Create a model object according to the view object identifier, the preset first mapping list, and the data to be displayed, wherein the first mapping list includes the view object identifier, the model object identifier corresponding to the view object identifier, and the model object name ; Create a view object according to the created model object and a preset second mapping list, where the second mapping list includes a model object identifier and a view object name corresponding to the model object identifier; Lay out the created view objects to generate pages. 2. The method according to claim 1, wherein said creating a model object according to the view object identifier, the preset first mapping list and the data to be displayed comprises: Determine the model object identifier and the model object name corresponding to the view object identifier according to the preset first mapping list; According to the determined model object name, call the preset object generation function to generate the object; Encapsulate the determined model object identifier and the data to be displayed in the generated object to obtain a model object. 3. The method according to claim 1, wherein said creating a view object according to the created model object and the preset second mapping list comprises: Parse the created model object to obtain the model object identifier; According to the second mapping list, determine the name of the view object corresponding to the model object identifier obtained by parsing; According to the determined name of the view object, a preset object generation function is invoked to generate the view object. 4. The method according to claim 1, wherein, before receiving and analyzing the data returned by the server, the method further comprises: In response to detecting the page generation operation triggered by the user, a data acquisition request is sent to the server. 5. The method of claim 1, wherein the method further comprises: In response to detecting a user-triggered view switching operation, calling a layout function corresponding to the view switching operation to change the layout of the created view object; According to the changed layout of the created view object, the page for switching views is obtained. 6. An apparatus for generating a page, comprising: The data receiving unit is configured to receive and parse the data sent by the server, the data includes the view object identifier and the data to be displayed; The model object creation unit is configured to create a model object according to the view object identifier, the preset first mapping list and the data to be displayed, wherein the first mapping list includes the view object identifier and the view object identifier corresponding The model object identifier and model object name of ; The view object creating unit is configured to create a view object according to the created model object and a preset second mapping list, wherein the second mapping list includes a model object identifier and a view object name corresponding to the model object identifier; The page generation unit is configured to lay out the created view objects to generate a page. 7. The apparatus according to claim 6, wherein the model object creation unit is further configured to: Determine the model object identifier and the model object name corresponding to the view object identifier according to the preset first mapping list; According to the determined model object name, call the preset object generation function to generate the object; Encapsulate the determined model object identifier and the data to be displayed in the generated object to obtain a model object. 8. The apparatus according to claim 6, wherein the view object creation unit is further configured to: Parse the created model object to obtain the model object identifier; According to the second mapping list, determine the name of the view object corresponding to the model object identifier obtained by parsing; According to the determined name of the view object, a preset object generation function is invoked to generate the view object. 9. The apparatus of claim 6, wherein the apparatus further comprises: The request sending unit is configured to send a data acquisition request to the server in response to detecting a user-triggered page generation operation before the data receiving unit receives and parses the data returned by the server. 10. The device according to claim 6, wherein the device further comprises a view switching unit configured to: In response to detecting a user-triggered view switching operation, calling a layout function corresponding to the view switching operation to change the layout of the created view object; According to the changed layout of the created view object, the page for switching views is obtained. 11. A terminal, comprising: one or more processors; a storage device on which one or more programs are stored, When the one or more programs are executed by the one or more processors, the one or more processors are made to implement the method according to any one of claims 1-5. 12. A computer-readable medium, on which a computer program is stored, wherein, when the program is executed by a processor, the method according to any one of claims 1-5 is realized.