CN101794240B - Method and system for aggregating data content - Google Patents
Method and system for aggregating data content Download PDFInfo
- Publication number
- CN101794240B CN101794240B CN201010001201.5A CN201010001201A CN101794240B CN 101794240 B CN101794240 B CN 101794240B CN 201010001201 A CN201010001201 A CN 201010001201A CN 101794240 B CN101794240 B CN 101794240B
- Authority
- CN
- China
- Prior art keywords
- widget
- output
- input
- aggregation
- user
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
- 238000000034 method Methods 0.000 title claims abstract description 37
- 230000004931 aggregating effect Effects 0.000 title claims abstract description 17
- 230000002776 aggregation Effects 0.000 claims abstract description 109
- 238000004220 aggregation Methods 0.000 claims abstract description 109
- 238000013507 mapping Methods 0.000 claims abstract description 20
- 230000004048 modification Effects 0.000 claims description 11
- 238000012986 modification Methods 0.000 claims description 11
- 230000004044 response Effects 0.000 claims description 6
- 238000006116 polymerization reaction Methods 0.000 claims description 3
- 230000003993 interaction Effects 0.000 abstract description 6
- 238000012545 processing Methods 0.000 description 7
- 230000006870 function Effects 0.000 description 6
- 238000010586 diagram Methods 0.000 description 4
- 230000008859 change Effects 0.000 description 3
- 235000014510 cooky Nutrition 0.000 description 2
- 230000000694 effects Effects 0.000 description 2
- 230000008569 process Effects 0.000 description 2
- 238000004891 communication Methods 0.000 description 1
- 238000011161 development Methods 0.000 description 1
- 238000005516 engineering process Methods 0.000 description 1
- 238000007781 pre-processing Methods 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/36—Software reuse
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Stored Programmes (AREA)
Abstract
The invention discloses a method for aggregating data content, which comprises the steps of analyzing an inputted Widget source code; establishing more than one inter-Widget input-output mapping relationships according to the selection of a user and generating an aggregating template; generating a Widget code according to the aggregating template and inserting the generated Widget code into the Widget source code; and using a Widget engine for running a Widget and the Widget source code, and using the Widget for reading an output variable from the Widget engine as the Widget outside the itself for input. The invention further discloses a system for aggregating the Widget data content, and the technical scheme can carry out interaction and aggregation on the data content between the Widgets, thereby meeting the personalization demands of the user and upgrading the experience of the user.
Description
Technical Field
The invention relates to a data aggregation technology in Web application, in particular to a method and a system for aggregating Widget data content.
Background
Widget is a client-side application that allows developers to embed content into Web files using Web standards. Widgets generally provide certain configuration functionality that allows users to customize. Due to the fact that the function of the Widget is specific, the reusability degree is high. The Widget is generally constructed on a certain platform, and the platform is responsible for managing the Widget, and meanwhile, the platform provides a series of Application Programming Interfaces (APIs) for the Widget to use. The third party can develop own widgets according to the development specifications provided by the platform and run on the platform. Generally, widgets can be classified into three categories according to the operating platform: desktop window Widget (desktop Widget), Mobile Widget (Mobile Widget), and Web Widget.
Fig. 1 shows a structure of an existing Widget, as shown in fig. 1, the Widget is composed of a user input (userlnput) and a processing Logic (Logic), the Widget provides an interface to receive the user input, the processing Logic obtains an output result according to the input, the processing Logic is written in a Web standard language JavaScript, and the output is displayed to a user by embedding the JavaScript in HTML.
Fig. 2 shows an existing Widget running system, as shown in fig. 2, the functions performed by widgets are more specific and single, multiple widgets run independently, no communication specification and standard are formed, no standard interface is defined for Widget output, and parameters between widgets cannot be directly transferred, so that the widgets cannot interact and form aggregation.
Disclosure of Invention
In view of this, the main objective of the present invention is to provide a method and a system for aggregating Widget data content, which can enable interaction and aggregation of data content between widgets, and meet personalized requirements of users.
In order to achieve the purpose, the technical scheme of the invention is realized as follows:
the invention provides a method for aggregating data contents, which comprises the following steps:
analyzing the input Widget source code; establishing more than one input/output mapping relation between widgets according to the selection of a user, and generating an aggregation template;
generating a Widget code according to the aggregation template, and inserting the generated Widget code into the Widget source code;
and the Widget engine runs the Widget and the Widget source code, and the Widget reads an output variable from a storage area of the Widget engine to be used as Widget input outside the Widget engine.
The analyzing the input Widget source code specifically comprises: acquiring the Widget source code; analyzing the input of the Widget and the output of the Widget; and transmitting the analyzed input variable name of the Widget and the analyzed output variable name of the Widget to the converter.
In the above scheme, the analyzing the Widget input according to the rule specifically includes: and the Widget analyzes and searches a specific label used for defining the user input in the Widget by using an interface for receiving the user input, and obtains the input of the Widget.
In the above scheme, the analyzing the output of the Widget specifically includes: and the logic of the Widget obtains the output of the Widget according to the rule of JavaScript output.
In the above scheme, the establishing of the input/output mapping relationship between more than one Widget and the generating of the aggregation template specifically include: obtaining the analyzed input of the Widget and the output of the Widget, and selecting the Widget needing to be aggregated by a user; receiving a modification item selected by a user, if the user selects the input of the Widget needing to be aggregated, displaying the stored Widget output variable name, and receiving the stored output variable name; if the user selects the output needing to be aggregated, receiving an output variable name to be stored, and generating a unique storage identifier according to the Widget name and the output variable name; judging whether the user completes all the modification items to be received, if so, generating an aggregation template according to the mapping relation; if not, the user selection is continuously judged.
In the above scheme, the generating of the polymerization template is: and the user generates the aggregation template according to a certain rule or appointed writing file, or the aggregation preprocessor automatically generates the aggregation template after the selection is carried out through a user interface.
In the above scheme, the storage area stores the output variables of the Widget and provides parameters for the Widget needing to be input.
The invention also provides a system for aggregating data content, comprising: a polymerization preprocessor and a Widget engine; wherein,
the aggregation preprocessor is used for analyzing the input Widget source code, establishing more than one input-output mapping relation among the Widgets according to the selection of a user and generating an aggregation template; generating a Widget code according to the aggregation template, and inserting the generated Widget code into the Widget source code;
and the Widget engine is used for operating the Widget and the Widget source code and providing a storage area for the output of the Widget.
Wherein the aggregation pre-processor further comprises: the system comprises an analysis module, a template generation module and a code generation module; wherein,
the analysis module is used for receiving the Widget source code and the aggregation template sent by the Widget engine, analyzing the input of the Widget and the output of the Widget, and transmitting the input variable name of the Widget and the output variable name of the Widget to the converter;
the template generation module is used for sending a response to the user after obtaining the analyzed Widget input and the analyzed Widget output, selecting the Widget needing aggregation and receiving the modification item selected by the user; when a user selects input needing to aggregate the Widget, displaying the stored Widget output variable name for the user to select, and when the user selects output needing to aggregate the Widget, receiving the output variable name to be stored; receiving a stored output variable name selected by a user for an input variable, generating a unique storage identifier for the output variable according to the Widget name and the output variable name, and generating an aggregation template according to a mapping relation;
the code generation template is used for analyzing the generated aggregation template, storing variables in the Widget codes and reading the stored variables in the Widget codes; and inserting all the acquired Widget codes output by the Widget into the Widget source codes.
In the above system, the Widget engine further includes: a storage area and a Widget; wherein,
the storage area is used for storing the output of the Widget and providing needed variables for the Widget which needs to be input;
and the Widget is used for providing an interface to receive the user input, obtaining an output result according to the user input and outputting the variable to a storage area of the Widget engine.
The method and the system for aggregating the Widget data content analyze the input Widget source code, establish the input and output mapping relation between the widgets according to the selection of the user, store the output variable by using the storage area, and read the variable from the storage area when the Widget source code after aggregation preprocessing runs on the Widget engine, thereby realizing the interaction and aggregation of the data content between the widgets, realizing the customized application of the user by using a plurality of widgets, achieving the effect of meeting the personalized requirements of the user and improving the experience of the user.
Drawings
Fig. 1 is an internal structure diagram of a conventional Widget;
fig. 2 is a schematic diagram of a system in the prior art when a Widget operates;
fig. 3 is a schematic overall flow chart of a method for implementing aggregation of Widget data content according to the present invention;
FIG. 4 is a flowchart illustrating a method for implementing a aggregation pre-processor to analyze Widget source codes according to the present invention;
FIG. 5 is a flowchart illustrating a method for implementing the aggregation pre-processor to create input and output mapping pairs according to the user's selection and generate an aggregation template according to the present invention;
FIG. 6 is a flowchart illustrating a method for implementing a preprocessor to aggregate a Widget code and insert the code into a Widget source code according to the present invention;
FIG. 7 is a flowchart illustrating a method for implementing a Widget engine to run Widget and Widget source codes according to the present invention;
fig. 8 is a schematic diagram of an internal structure of a system for aggregating Widget data content according to the present invention;
fig. 9 is a schematic diagram illustrating an effect of implementing aggregation of Widget data content according to an embodiment of the present invention.
Detailed Description
In order to realize data content aggregation and interaction between widgets, the output of the Widget needs to be obtained and is transmitted to other widgets as input as a parameter; the basic idea of the invention is: analyzing the input Widget source code, establishing the mapping relation of input and output between widgets according to the selection of a user, and adopting a storage area to store an output variable, so that the input and the output between widgets can be interacted through the storage area.
Specifically, the aggregation preprocessor can be used as an independent module, the input is the Widget source code, and the output is the processed Widget source code, so that the Widget engine calls the aggregation preprocessor to process the Widget source code before deploying the Widget source code, and when the Widget engine runs the Widget source code, the Widget source code processed by the aggregation preprocessor can realize interaction and aggregation of data contents.
The invention is further described in detail below with reference to the drawings and the specific embodiments.
As shown in fig. 3, the method for aggregating Widget data content provided by the present invention includes:
step 301, analyzing an input Widget source code;
step 302, establishing more than one input/output mapping relation between widgets according to the selection of a user, and generating an aggregation template;
step 303, generating a Widget code according to the aggregation template, and inserting the generated Widget code into a Widget source code;
and step 304, the Widget engine runs the Widget and the Widget source code, and the Widget reads the output variable from the storage area in the Widget engine to be used as the Widget input outside the Widget engine.
Fig. 4 is a specific method for implementing step 301 in fig. 3, and is a flowchart of a method for analyzing an input Widget source code by an aggregation preprocessor according to the present invention, as shown in fig. 4, the method includes the following steps:
step 401, receiving a Widget source code and an aggregation template sent by a Widget engine;
the Widget code is generally an XML code including a JavaScript code.
Step 402, analyzing the input of the Widget;
specifically, the Widget uses an interface for receiving user input, such as: some widgets use a specific tag, such as a < userpuf > tag, to define the user's input, so that the aggregation preprocessor obtains the Widget's input by analyzing and searching the specific tag used to define the user's input in the Widget.
Step 403, analyzing the output of the Widget;
specifically, the Widget does not set an interface for outputting the code, but the logic of the Widget is implemented by JavaScript, so that the output of the Widget is obtained according to the rule of JavaScript output. For example, JavaScript can use document. write (), lnertext (), lnerhtml () methods to dynamically output the contents of a Widget, and can analyze and obtain the output of the Widget by finding these flags.
And step 404, transmitting the analyzed input variable name of the Widget and the analyzed output variable name of the Widget to the converter.
Here, the converter is configured to convert the input variable name of the Widget and the output variable name of the Widget into a format required by the Widget, and the input variable name of the Widget and the output variable name of the Widget converted by the converter may be utilized by a next step.
Fig. 5 is a flowchart of a method for the aggregation preprocessor to establish an input/output mapping relationship between more than one Widget according to a selection of a user and generate an aggregation template, where the method is specifically implemented in step 302 in fig. 3, and as shown in fig. 5, the method includes the following steps:
step 501, after obtaining the analyzed Widget input and Widget output, sending a response to a user in a file or graphical interface manner, and the user selecting a Widget to be aggregated according to the response sent by the aggregation pre-processor.
Step 502, receiving a modification item selected by a user, and executing step 503 if the user selects the input of the Widget to be aggregated; if the user selects the output of the Widget that needs to be aggregated, step 504 is performed.
Wherein the change item includes: the input of the Widget needing aggregation and the output of the Widget needing aggregation.
Step 503, displaying the stored Widget output variable name for the user to select;
the following Widget output variable names are exemplified by O1, O2.. On in fig. 7.
Step 504, receiving an output variable name to be stored selected by a user;
assume that the user-selected Widget output variable name is O1 as an example.
Step 505, receiving a stored output variable name selected by a user for an input variable;
for example: the input variable selected by the user is i2 in fig. 7, and the output variable is O1 in fig. 7.
Step 506, generating a unique storage identifier for the output variable in step 404 according to the Widget name and the output variable name.
Here, the Widget name is a name of a Widget in a Widget engine defined by a user according to a requirement, and is used for distinguishing a plurality of widgets in the Widget engine.
Step 507, judging whether the user completes all the modification items to be received, if so, executing step 508; if not, returning to step 502, and continuing to judge whether the modification item selected by the user is Widget input or Widget output.
And step 508, generating an aggregation template according to the mapping relation.
If: the input of the Widget1(zipcode _ map) is obtained as zipcode through the processing of the aggregation preprocessor, and the output of the Widget1(zipcode _ map) is cityname; input of Widget2(Real _ estate _ info) is city and output of Widget2(Real _ estate _ info) is Real _ estate, the user wishes to aggregate the data content of Widget1 and Widget2, i.e.: the output citylame of the Widget1 is used as the input of the Widget2, and a user can write a file according to a certain rule or convention to generate an aggregation template or automatically generate the aggregation template by an aggregation preprocessor after the selection of the user interface.
The aggregation template represents aggregation between widgets, and can be defined according to the following format:
<mashup>
<widget_out name:>
<output name:>
</output>
</widget_out>
<widget_in name:>
<input name:>
</input>
</widget_in>
<mashup>
such as: the aggregation of the zip code Widget and the real estate information Widget can be represented by an aggregation template as follows:
<mashup>
<widget_out name:zipcode_map>
<output name:cityname>
</output>
</widget_out>
<widget_in name:Real_estate_info>
<input name:city>
</input>
</widget_in>
<mashup>
fig. 6 is a flowchart of a specific implementation method of step 303 in fig. 3, and is a flowchart of a method for generating a Widget code according to an aggregation template and inserting the generated Widget code into a Widget source code, as shown in fig. 6, the method includes the following steps:
step 601, the aggregation template generated in step 508 is analyzed.
Step 602, for the variable name corresponding to the output tag < output > in the aggregation template, storing the variable in the Widget code according to the < Widget _ out > tag in the aggregation template.
Such as: for the aggregation template in step 508, the code inserted to store the output (O1) cityname variable of Widget1(zipcode _ map) is setCookie ("acityname").
In step 603, for the variable name corresponding to the input tag < input > in the aggregation template, the storage variable is read in the Widget code according to the < Widget _ in > tag in the aggregation template.
Such as: for the aggregation template in step 508, the code for Input (i1) city read O1 of Widget2(Real _ estate _ info) is var city ═ getcookie byname (cookie obj, "city").
And step 604, inserting all the acquired Widget codes output by the Widget into the Widget source codes.
Here, the inserting may be writing the code output by all widgets into the Widget engine by the user through the editing interface writing program.
Fig. 7 is a specific implementation method of step 304 in fig. 3, which is a flowchart of a method for operating a Widget and a Widget source code by a Widget engine of the present invention, and as shown in fig. 7, the method includes:
widget1 provides an interface to receive user input i1, and processing logic in the Widget obtains output results O1, O2, etc. based on this user input; the Widget1 obtains an output O1 according to the input, and outputs an output variable O1 obtained at the same time to a storage area in the Widget engine; when the Widget source code processed by the aggregation preprocessor runs on the Widget engine, the Widget can read the variables from the storage area, so that the Widget2 can read the output variable O1 of the Widget1 from the storage area as the input of the Widget engine; and then the Widget2 outputs O2 and outputs a variable O2 to a storage area in the Widget engine, and so on, so as to realize the aggregation of the data content between the widgets.
The storage area in the Widget engine stores the output variables O1 and O2.. On of the Widget and provides parameters for the Widget which needs to be input, so that the input and output between the Widgets can realize the interaction of the data content of the Widget by using the storage area. The user can change the number of widgets in the Widget engine according to the requirement, and the user can also select the medium as the storage area according to the requirement.
In order to implement the foregoing method, the present invention further provides a system for aggregating Widget data content, as shown in fig. 8, the system includes: an aggregation preprocessor 81, a Widget engine 82; wherein,
the aggregation preprocessor 81 is configured to analyze the input Widget source code, establish an input/output mapping relationship between more than one Widget according to a selection of a user, and generate an aggregation template; generating a Widget code according to the aggregation template, and inserting the generated Widget code into a Widget source code;
the aggregation pre-processor 81 further includes: an analysis module 811, a template generation module 812, a code generation module 813; wherein,
the analysis module 811 is configured to receive the Widget source code and the aggregation template sent by the Widget engine, analyze the input of the Widget and the output of the Widget, and finally transmit the input variable name of the Widget and the output variable name of the Widget to the converter.
Here, the converter is configured to convert the variable names of the Widget input and the Widget output into the format required by the Widget in the template generating module 812, and the variable names of the Widget input and the Widget output converted by the converter may be utilized by the template generating module 812.
The template generating module 812 is configured to send a response to the user in a file or graphical interface mode after obtaining the input and output of the analyzed Widget, the user selects the Widget to be aggregated according to the response sent by the aggregation preprocessor, and receives a modification item selected by the user, and when the user selects the input of the Widget to be aggregated, the stored Widget output variable name is displayed for the user to select; when a user selects output needing to aggregate the Widget, receiving an output variable name to be stored, which is selected by the user; receiving a stored output variable name selected by a user for an input variable; and generating a unique storage identifier for the output variable according to the Widget name and the output variable name, and finally generating an aggregation template according to the mapping relation.
The Widget name is the name of a Widget in a Widget engine defined by a user according to requirements, and is used for distinguishing a plurality of widgets in the Widget engine.
The code generation template 813 is used for analyzing the generated aggregation template, storing variables in the Widget code according to the < Widget _ out > tag in the aggregation template for the variable name corresponding to the output tag in the aggregation template; reading a storage variable from a Widget code according to a < Widget _ in > tag in the aggregation template for a variable name corresponding to an input tag in the aggregation template; and finally, inserting all the acquired codes output by the Widget into the Widget source codes.
The Widget engine 82 is used for operating Widget and Widget source codes and providing a storage area for Widget output;
the Widget engine further comprises: storage area 821, Widget; wherein,
a storage area 821, configured to store an output of the Widget and provide a required variable for the Widget needing to be input;
here, the input and output between widgets can use the storage area to realize the intersection of the data content of the widgets; the user can select a medium as a storage area according to the requirement, and in this embodiment, a Cookie is selected as an output variable of the storage area medium storage Widget.
The Widget is used for providing an interface to receive user input, and the processing logic in the Widget obtains an output result according to the user input and outputs a variable to a storage area of the Widget engine;
here, the user can change the number of widgets in the Widget engine as needed.
The following describes a detailed implementation of an embodiment of the present invention with reference to the drawings.
Fig. 9 is a specific embodiment of aggregating the Widget data content, and as shown in fig. 9, three widgets are processed by an aggregation preprocessor to generate a new Mashup application, so that data aggregation between widgets is realized.
Three widgets in fig. 9 are mutually independent widgets, fig. 9 sequentially includes an input box Widget, a map Widget and a property information Widget from left to right, the input box Widget has a function of displaying a zip code on a Widget interface after the zip code is input, the map Widget has a function of displaying a map of a geographical position corresponding to the zip code and a weather condition on the Widget interface after the zip code is input, and the property information Widget has a function of displaying property related information of a city on the Widget interface after a city name is input.
After the aggregation preprocessor processing, the three widgets realize the aggregation of the data content, the function realized after the aggregation is to input the postal code in the input frame Widget, the postal code is displayed on the Widget interface, meanwhile, the map and the weather forecast of the geographic position corresponding to the postal code are displayed on the map Widget, and the house property information list of the city corresponding to the geographic position is displayed on the house property information Widget.
How the aggregation preprocessor processes the three widgets codes is described below in steps, specifically,
firstly, an aggregation preprocessor analyzes input and output of the Widget; the input and output analysis results of the input frame Widget, the map Widget and the real estate information Widget are as follows:
Widget name：Input initial input：zipcode output：zipcode
Widget name：Weather Map input：zipcode map output：cityname
Widget name：Real Estate input：city output：real estate infolist
and secondly, the aggregation preprocessor selects and establishes an input and output mapping relation according to the Widget input and output in the first step to generate an aggregation template.
In this embodiment, when the user selects Widget Input, an output zip code (zipcode) of the Widget (Input _ initial) is used as an Input zip code (zipcode _ map) of a map Widget (weather map), an output city name (cityname) of the map Widget (weather map) is used as an Input city name (city) of the property information list Widget, and the following aggregation templates are used to represent a data content aggregation relationship between the three:
<mashup>
<widget_out name＝Input_initial>
<output name＝zipcode>
</output>
</widget_out>
<widget_in name＝Weather Map>
<input name＝zipcode_map>
</input>
</widget_in>
</mashup>
<mashup>
<widget_out name＝Weather Map>
<output name＝cityname>
</output>
</widget_out>
<widget_in name＝Real Estate>
<input name＝city>
</input>
<widget_in>
</mashup>
and thirdly, generating a Widget code by the aggregation preprocessor according to the aggregation template formed in the second step, and inserting the code into the Widget source code.
The above description is only exemplary of the present invention and should not be taken as limiting the scope of the present invention, and any modifications, equivalents, improvements, etc. that are within the spirit and principle of the present invention should be included in the present invention.
Claims (10)
1. A method of aggregating data content, the method comprising:
analyzing the input Widget source code; establishing more than one input/output mapping relation between widgets according to the selection of a user, and generating an aggregation template;
analyzing the generated aggregation template, storing variables in the Widget code according to the < Widget _ out > tag in the aggregation template for the variable name corresponding to the output tag < output > in the aggregation template; reading a storage variable in a Widget code according to a < Widget _ in > tag in an aggregation template for a variable name corresponding to an input tag < input > in the aggregation template; inserting all acquired Widget codes output by Widget into Widget source codes;
and the Widget engine runs the Widget and the Widget source code, and the Widget reads an output variable from a storage area of the Widget engine to be used as Widget input outside the Widget engine.
2. The method of claim 1, wherein analyzing the input Widget source code specifically comprises:
acquiring the Widget source code;
analyzing the input of the Widget and the output of the Widget; and transmitting the analyzed input variable name of the Widget and the analyzed output variable name of the Widget to the converter.
3. The method of claim 2, wherein the input for analyzing the Widget specifically is: and the Widget analyzes and searches a specific label used for defining the user input in the Widget by using an interface for receiving the user input, and obtains the input of the Widget.
4. The method of claim 2, wherein the analyzing the output of the Widget specifically comprises: and the logic of the Widget obtains the output of the Widget according to the rule of JavaScript output.
5. The method of claim 1, wherein the establishing of the input/output mapping relationship among the widgets and the generating of the aggregation template specifically comprise:
obtaining the analyzed input of the Widget and the output of the Widget, and selecting the Widget needing to be aggregated by a user;
receiving a modification item selected by a user, if the user selects the input of the Widget needing to be aggregated, displaying the stored Widget output variable name, and receiving the stored output variable name; if the user selects the output needing to be aggregated, receiving an output variable name to be stored, and generating a unique storage identifier according to the Widget name and the output variable name;
judging whether the user completes all the modification items to be received, if so, generating an aggregation template according to the mapping relation; if not, the user selection is continuously judged.
6. The method of claim 5, wherein the generating the aggregated template is: and the user generates the aggregation template according to a certain rule or appointed writing file, or the aggregation preprocessor automatically generates the aggregation template after the selection is carried out through a user interface.
7. The method of claim 1, wherein the storage area stores output variables of the Widget and provides parameters for the Widget needing to be input.
8. A system for aggregating data content, the system comprising: a polymerization preprocessor and a Widget engine; wherein,
the aggregation preprocessor is used for analyzing the input Widget source code, establishing more than one input-output mapping relation among the Widgets according to the selection of a user and generating an aggregation template; analyzing the generated aggregation template, storing variables in the Widget code according to < Widget _ out > tags in the aggregation template for variable names corresponding to output tags < output > in the aggregation template, reading the stored variables in the Widget code according to < Widget _ in > tags in the aggregation template for variable names corresponding to input tags < input > in the aggregation template, and inserting all acquired Widget codes output by Widget into Widget source codes;
and the Widget engine is used for operating the Widget and the Widget source code and providing a storage area for the output of the Widget.
9. The system of claim 8, wherein the aggregation pre-processor further comprises: the system comprises an analysis module, a template generation module and a code generation module; wherein,
the analysis module is used for receiving the Widget source code and the aggregation template sent by the Widget engine, analyzing the input of the Widget and the output of the Widget, and transmitting the input variable name of the Widget and the output variable name of the Widget to the converter;
the template generation module is used for sending a response to the user after obtaining the analyzed Widget input and the analyzed Widget output, selecting the Widget needing aggregation and receiving the modification item selected by the user; when a user selects input needing to aggregate the Widget, displaying the stored Widget output variable name for the user to select, and when the user selects output needing to aggregate the Widget, receiving the output variable name to be stored; receiving a stored output variable name selected by a user for an input variable, generating a unique storage identifier for the output variable according to the Widget name and the output variable name, and generating an aggregation template according to a mapping relation;
the code generation template is used for analyzing the generated aggregation template, storing variables in the Widget codes and reading the stored variables in the Widget codes; and inserting all the acquired Widget codes output by the Widget into the Widget source codes.
10. The system of claim 8 or 9, wherein the Widget engine further comprises: a storage area and a Widget; wherein,
the storage area is used for storing the output of the Widget and providing needed variables for the Widget which needs to be input;
and the Widget is used for providing an interface to receive the user input, obtaining an output result according to the user input and outputting the variable to a storage area of the Widget engine.
Priority Applications (2)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201010001201.5A CN101794240B (en) | 2010-01-04 | 2010-01-04 | Method and system for aggregating data content |
| PCT/CN2010/076210 WO2011079619A1 (en) | 2010-01-04 | 2010-08-20 | Method and system for aggregating data |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201010001201.5A CN101794240B (en) | 2010-01-04 | 2010-01-04 | Method and system for aggregating data content |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN101794240A CN101794240A (en) | 2010-08-04 |
| CN101794240B true CN101794240B (en) | 2015-01-28 |
Family
ID=42586950
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201010001201.5A Active CN101794240B (en) | 2010-01-04 | 2010-01-04 | Method and system for aggregating data content |
Country Status (2)
| Country | Link |
|---|---|
| CN (1) | CN101794240B (en) |
| WO (1) | WO2011079619A1 (en) |
Families Citing this family (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101794240B (en) * | 2010-01-04 | 2015-01-28 | 中兴通讯股份有限公司 | Method and system for aggregating data content |
| CN103092582B (en) * | 2011-10-31 | 2016-01-20 | 国际商业机器公司 | For the treatment of the method and system of the event of issue with the event of subscription |
| CN103455459A (en) * | 2012-05-31 | 2013-12-18 | 国际商业机器公司 | Method and system for transmitting payload data to iWidget |
| CN102866911B (en) * | 2012-09-12 | 2015-03-25 | 北京航空航天大学 | Mashup application establishing method and device |
| CN110874216B (en) * | 2018-08-31 | 2023-07-28 | 广州虎牙信息科技有限公司 | Complete code generation method, device, equipment and storage medium |
Citations (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101533410A (en) * | 2009-04-13 | 2009-09-16 | 浙江大学 | Widget content buffering method facing mobile terminal |
Family Cites Families (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20080168382A1 (en) * | 2007-01-07 | 2008-07-10 | Louch John O | Dashboards, Widgets and Devices |
| US20090100329A1 (en) * | 2007-10-04 | 2009-04-16 | Danny Javier Espinoza | Method of Deploying a Web Widget In a Desktop Widget Platform |
| CN101794240B (en) * | 2010-01-04 | 2015-01-28 | 中兴通讯股份有限公司 | Method and system for aggregating data content |
-
2010
- 2010-01-04 CN CN201010001201.5A patent/CN101794240B/en active Active
- 2010-08-20 WO PCT/CN2010/076210 patent/WO2011079619A1/en active Application Filing
Patent Citations (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101533410A (en) * | 2009-04-13 | 2009-09-16 | 浙江大学 | Widget content buffering method facing mobile terminal |
Non-Patent Citations (2)
| Title |
|---|
| 李峰,李春旺.《Mashup关键技术研究》.《现代图书情报技术》.2009,(第1期), * |
| 秦灵伶,王文东,贾霞,董振江.《Mashup技术及其发展趋势》.《电信科学》.2009,(第9期), * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN101794240A (en) | 2010-08-04 |
| WO2011079619A1 (en) | 2011-07-07 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN106598574B (en) | Page rendering method and device | |
| CN101946248B (en) | Method and apparatus for providing API service and making API mash-up, and computer readable recording medium thereof | |
| US20190129734A1 (en) | Data collection workflow extension | |
| US9619217B2 (en) | Methods and systems for cloud computing | |
| US8219900B2 (en) | Programmatically hiding and displaying Wiki page layout sections | |
| US20190180098A1 (en) | Content based transformation for digital documents | |
| CN103389895B (en) | A kind of generation method and system of front end page | |
| CN108292231A (en) | It generates and applies from data | |
| CN106537426A (en) | Automatically generating execution sequences for workflows | |
| CN108027721B (en) | Techniques for configuring a general program using controls | |
| EP2041674A1 (en) | Method for defining a wiki page layout using a wiki page | |
| CN101794240B (en) | Method and system for aggregating data content | |
| CN112199086A (en) | Automatic programming control system, method, device, electronic device and storage medium | |
| CN112363695B (en) | PMML file and integration method of runtime environment and industrial software thereof | |
| US20190147104A1 (en) | Method and apparatus for constructing artificial intelligence application | |
| CN110232131A (en) | Intention material searching method and device based on intention label | |
| CN109271160A (en) | Active rule construction method, device and computer system, medium | |
| CN112947900A (en) | Web application development method and device, server and development terminal | |
| CN112785284B (en) | Message warehousing method and device based on structured document | |
| CN114676705A (en) | Dialogue relation processing method, computer and readable storage medium | |
| CN110083685B (en) | Data configuration method and device for intention recognition | |
| CN116522871A (en) | Data format conversion method, device, equipment and storage medium | |
| CN111506305A (en) | Tool kit generation method and device, computer equipment and readable storage medium | |
| US9075871B2 (en) | Technique to classify data displayed in a user interface based on a user defined classification | |
| CN109117207B (en) | Data processing method of business process model |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| C06 | Publication | ||
| PB01 | Publication | ||
| C10 | Entry into substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| C14 | Grant of patent or utility model | ||
| GR01 | Patent grant |