CN109343968B - Method and related device for acquiring data - Google Patents
Method and related device for acquiring data Download PDFInfo
- Publication number
- CN109343968B CN109343968B CN201810872389.7A CN201810872389A CN109343968B CN 109343968 B CN109343968 B CN 109343968B CN 201810872389 A CN201810872389 A CN 201810872389A CN 109343968 B CN109343968 B CN 109343968B
- Authority
- CN
- China
- Prior art keywords
- data
- function
- information
- pkbean
- allinfo
- 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 97
- 238000006243 chemical reaction Methods 0.000 claims abstract description 49
- 230000008569 process Effects 0.000 claims abstract description 38
- 235000010627 Phaseolus vulgaris Nutrition 0.000 claims abstract description 13
- 244000046052 Phaseolus vulgaris Species 0.000 claims abstract description 13
- 238000012423 maintenance Methods 0.000 claims abstract description 11
- 230000006870 function Effects 0.000 claims description 252
- 238000012545 processing Methods 0.000 claims description 15
- 239000011800 void material Substances 0.000 claims description 9
- 238000001514 detection method Methods 0.000 claims description 7
- 238000004806 packaging method and process Methods 0.000 claims description 7
- 125000004122 cyclic group Chemical group 0.000 claims description 6
- 238000005538 encapsulation Methods 0.000 claims description 6
- 238000012795 verification Methods 0.000 claims description 3
- 238000004590 computer program Methods 0.000 description 18
- 238000013461 design Methods 0.000 description 15
- 238000010586 diagram Methods 0.000 description 14
- 238000010276 construction Methods 0.000 description 7
- 238000012986 modification Methods 0.000 description 5
- 230000004048 modification Effects 0.000 description 5
- 230000003068 static effect Effects 0.000 description 3
- 238000011161 development Methods 0.000 description 2
- 230000004075 alteration Effects 0.000 description 1
- 238000013459 approach Methods 0.000 description 1
- 238000013500 data storage Methods 0.000 description 1
- 238000012938 design process Methods 0.000 description 1
- 238000011423 initialization method Methods 0.000 description 1
- 238000007726 management method Methods 0.000 description 1
- 238000004519 manufacturing process Methods 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 238000012546 transfer Methods 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/54—Interprogram communication
- G06F9/546—Message passing systems or structures, e.g. queues
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
Abstract
The embodiment of the invention discloses a method for acquiring data and a related device. The method provided by the embodiment of the invention comprises the following steps: defining target data in a PKBean class of a data Bean object, wherein the target data is a private type; setting a set function and a get function for target data; using a Map data structure in the similar PKBean, designing a maintenance variable Map < String, Object > allinfo of the global data; storing parameter information used for setting a global variable in the set function in allInfo according to a Map data structure, and returning content information of the global variable according to the get function; defining a calibration set object listTarget in the class PKBean, wherein the listTarget is used for verifying data in the class PKBean; determining whether the allInfo lacks data information according to the listTarget; if not, performing a conversion process through a to String () function, wherein the to String () function is used for converting the data information in the allInfos into an object of a String type; and calling a PKBean and toString () function in the PKbean-like function to acquire the C + + message according to the String type object.
Description
Technical Field
The present invention relates to the field of development platforms, and in particular, to a method for acquiring data and a related apparatus.
Background
In the traditional scheme, the construction of the C + + message is realized by manually writing codes by a programmer and splicing the written codes one by one. Such a method may make the whole concatenation flow complicated and difficult to process, and the process of acquiring and concatenating data may also take a lot of time, resulting in very inefficient construction of C + + messages. Therefore, in practical application, the traditional method for constructing the parameter list sent to the C + + bullet screen server also has the problems of long construction time and low construction efficiency.
Therefore, compared with a splicing method for realizing sending parameters one by one in a manual mode in the traditional scheme, how to quickly and effectively construct a parameter list sent to the C + + bullet screen server and ensure the integrity of the parameters is an urgent problem to be solved.
Disclosure of Invention
The embodiment of the invention provides a method and a related device for acquiring data, which are used for ensuring the integrity of parameters and improving the efficiency of acquiring C + + messages.
A first aspect of an embodiment of the present invention provides a method for acquiring data, where the method is used to acquire a C + + message in an Android system, and includes: defining target data in a PKBean class of a data Bean object, wherein the target data is a private type; setting a set function and a get function for the target data; using a Map data structure in the PKBean-like, designing a maintenance variable Map < S of global data, wherein S is used for representing the name of stored data, Object is used for representing the information of the stored data, and allinfo is used for representing the collection of various types of data stored in the PKBean-like; storing parameter information used for setting a global variable in the set function in the allInfo according to the Map data structure, and returning content information of the global variable according to the get function; defining a calibration set object listTarget in the class PKBean, wherein the listTarget is used for verifying data in the class PKBean; determining whether the allInfo lacks data information according to the listTarget; if not, performing a conversion process through a to String () function, wherein the to String () function is used for converting the data information in the allInfos into a String type object; and calling a PKBean and toString () function in the PKbean-like function to acquire the C + + message according to the String type object.
In a possible embodiment, said determining whether said alllnfo lacks data information according to said listTarget comprises: defining a checkParam function, wherein the checkParam function is used for carrying out detection operation; calling listtarget.add () in the listTarget to add a check object in the checkParam function; sequentially traversing and extracting data information in the allInfo, wherein the identification information of the data information is item; calling a listTarget-contacts (item) function in the listTarget to judge whether the listTarget contains the data information; if the data information is contained, removing the data information from the listTarget; if the data information is not contained, the cyclic check is continuously carried out; when the allInfo loop is finished, judging whether the listTarget has elements; if yes, determining that the allInfo lacks the information content; and if not, determining that the allInfo contains all information content.
In one possible embodiment, the target data includes width data of int type and height data of int type; the function of setting a set function and the function of a get function on the target data comprise: setting the functions of the set function and the get function according to the following manner: public void setWidth (int width) { }; public int getWidth () { }.
In one possible embodiment, the conversion flow by the to String () function includes: defining a builder object of a character string splicing class in the Stringbuilder type; calling a function ap (PKBean { ") in the builder object to add name prefix information (PKBean {") in the builder object; sequentially traversing and extracting data information in the allInfo; adding data information in the allinfo to the builder object, and packaging the data information; and after the data information in the allinfo is packaged in the builder object, calling a builder tostring () function to convert the data in the builder object into the String type object.
In a possible embodiment, said sequentially traversing and extracting the data information in the allInfos includes: calling an allinfo.get (width) function to acquire value information width of the width data; get ("length") function to obtain Value information length Value of the length data.
In a possible embodiment, the adding, to the builder object, the data information in the allinfo, and encapsulating the data information includes: calling an ap (width) function in the builder object to insert value information width of the width data in the builder object, so that the data in the builder object is composed of the following components: PKBean { width ═ width value; calling a builder () function in the builder object to add a delimiter; calling an end (length) function in the builder object, inserting value information (length) of the length data into the builder object, so that the data in the builder object is composed of the following components: PKBean { width ═ length; calling a builder () function in the builder object to add an end character to realize the encapsulation of the data information.
In a possible embodiment, after the performing the conversion process through the to String () function, before the calling the PKBean, the to String () function in the class PKBean to obtain the C + + message according to the object of the String type, the method further includes: calling a return builderStr function to return the object of the String type, wherein the builderStr is used for representing the object of the String type.
A second aspect of the embodiments of the present invention provides an obtaining apparatus, where the apparatus is configured to obtain a C + + message in an Android system, and the apparatus includes: the defining unit is used for defining target data in a PKBean class of a data Bean object, wherein the target data is a private type; the setting unit is used for setting a set function and a get function for the target data; the defining unit is further used for designing a maintenance variable Map < S of global data by using a Map data structure in the class PKBean, wherein S is used for representing the name of stored data, Object is used for representing information of the stored data, and allinfo is used for representing a set for storing various types of data in the class PKBean; the storage unit is used for storing the parameter information used for setting the global variable in the set function in the allInfo according to the Map data structure and returning the content information of the global variable according to the get function; the defining unit is further configured to define a listTarget of a calibration set in the class PKBean, where the listTarget is used to perform verification processing on data in the class PKBean; a determining unit, configured to determine whether the allinfo lacks data information according to the listTarget; if not, performing a conversion process through a to String () function, wherein the to String () function is used for converting the data information in the allinfo into an object of a String type; and the calling unit is used for calling the PKBean and toString () functions in the PKbeans of the class so as to acquire the C + + message according to the objects of the String type.
In a possible embodiment, the determining unit is specifically configured to: defining a checkParam function, wherein the checkParam function is used for carrying out detection operation; calling listtarget.add () in the listTarget to add a check object in the checkParam function; sequentially traversing and extracting data information in the allInfo, wherein the identification information of the data information is item; calling a listTarget-contacts (item) function in the listTarget to judge whether the listTarget contains the data information; if the data information is contained, removing the data information from the listTarget; if the data information is not contained, the cyclic check is continuously carried out; when the allInfo loop is finished, judging whether the listTarget has elements; if yes, determining that the allInfo lacks the information content; and if not, determining that the allInfo contains all information content.
In a possible embodiment, the target data includes width data of int type and height data of int type, and the setting unit is specifically configured to: setting the functions of the set function and the get function according to the following manner: public void setWidth (int width) { }; public int getWidth () { }.
In a possible embodiment, the conversion unit is specifically configured to: defining a builder object of a character string splicing class in the Stringbuilder type; calling a function ap (PKBean { ") in the builder object to add name prefix information (PKBean {") in the builder object; sequentially traversing and extracting data information in the allInfo; adding data information in the allinfo to the builder object, and packaging the data information; and after the data information in the allinfo is packaged in the builder object, calling a builder tostring () function to convert the data in the builder object into the String type object.
In a possible embodiment, the conversion unit is specifically configured to: calling an allinfo.get (width) function to acquire value information width of the width data; get ("length") function to obtain Value information length Value of the length data.
In a possible embodiment, the conversion unit is specifically configured to: calling an ap (width) function in the builder object to insert value information width of the width data in the builder object, so that the data in the builder object is composed of the following components: PKBean { width ═ width value; calling a builder () function in the builder object to add a delimiter; calling an end (length) function in the builder object, inserting value information (length) of the length data into the builder object, so that the data in the builder object is composed of the following components: PKBean { width ═ length; calling a builder () function in the builder object to add an end character to realize the encapsulation of the data information.
In a possible embodiment, the invoking unit is further configured to: calling a return builderStr function to return the object of the String type, wherein the builderStr is used for representing the object of the String type.
A third aspect of the present invention provides an electronic device, comprising a memory and a processor, wherein the processor is configured to implement the steps of the method for acquiring data according to any one of the above items when executing a computer management program stored in the memory.
A fourth aspect of the present invention provides a computer-readable storage medium having a computer management-like program stored thereon, characterized in that: the computer management like program when executed by a processor performs the steps of the method of obtaining data as described in any one of the above.
According to the technical scheme, the embodiment of the invention has the following advantages: defining target data in a PKBean class of a data Bean object, wherein the target data is a private type; setting a set function and a get function for the target data; using a Map data structure in the PKBean-like, designing a maintenance variable Map < S of global data, wherein S is used for representing the name of stored data, Object is used for representing the information of the stored data, and allinfo is used for representing the collection of various types of data stored in the PKBean-like; storing parameter information used for setting a global variable in the set function in the allInfo according to the Map data structure, and returning content information of the global variable according to the get function; defining a calibration set object listTarget in the class PKBean, wherein the listTarget is used for verifying data in the class PKBean; determining whether the allInfo lacks data information according to the listTarget; if not, performing a conversion process through a to String () function, wherein the to String () function is used for converting the data information in the allInfos into a String type object; and calling a PKBean and toString () function in the PKbean-like function to acquire the C + + message according to the String type object. In the embodiment of the invention, the integrity of the parameters is ensured, the construction efficiency of the C + + message can be effectively improved, the data acquisition difficulty and the splicing difficulty can be reduced, and the C + + message acquisition efficiency is greatly improved.
Drawings
FIG. 1 is a flow chart of a possible method for obtaining data according to an embodiment of the present invention;
fig. 2 is a schematic structural diagram of a possible acquisition apparatus according to an embodiment of the present invention;
fig. 3 is a schematic diagram of a hardware structure of a possible electronic device according to an embodiment of the present invention;
fig. 4 is a schematic hardware structure diagram of a possible computer-readable storage medium according to an embodiment of the present invention.
Detailed Description
The embodiment of the invention provides a method and a related device for acquiring data, which are used for ensuring the integrity of parameters and improving the efficiency of acquiring C + + messages.
The technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the drawings in the embodiments of the present invention, and it is obvious that the described embodiments are only a part of the embodiments of the present invention, and not all of the embodiments. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present invention.
The terms "first," "second," "third," "fourth," and the like in the description and in the claims of the present application and in the drawings described above, if any, are used for distinguishing between similar elements and not necessarily for describing a particular sequential or chronological order. It will be appreciated that the data so used may be interchanged under appropriate circumstances such that the embodiments described herein may be practiced otherwise than as specifically illustrated or described herein. Furthermore, the terms "comprises," "comprising," and "having," and any variations thereof, are intended to cover a non-exclusive inclusion, such that a process, method, system, article, or apparatus that comprises a list of steps or elements is not necessarily limited to those steps or elements expressly listed, but may include other steps or elements not expressly listed or inherent to such process, method, article, or apparatus.
Referring to fig. 1, a flowchart of a method for acquiring data according to an embodiment of the present invention includes:
101. defining target data in a PKBean class of a data Bean object;
in the conventional scheme, the data carrier has a data acquisition process, and the data acquisition process is complex, so that the complexity of data acquisition in the conventional scheme is increased. In view of this, in this step, a new method for designing a data carrier will be described to simplify the data acquisition process, which is as follows:
in the Android development, data is usually stored in a data Bean object, so the data acquisition speed is the fastest if the designed data acquisition is in the Bean object. Based on this, the design of data bearers can be implemented in a PKBean-like of a data Bean object. It should be noted that several pieces of field information, such as width of int type and height data of int type, are included in the PKBean class. For convenience of description, in the embodiment of the present invention, only the use case including these two pieces of data is described, and if other types of field information or data are also included, the processing manner is similar to the manner of processing the width of the int type and the height data of the int type, and details are not described here again.
In the embodiment of the present invention, the target data may be the two data, that is, the width data of int type and the height data of int type, and the specific definition mode is as follows:
private int width；
private int height；
two local variables width and height are defined in the PKBean-like, the core of which is a private (private) type, and the parameter types of which are data of int integer type. Next, setWidth and getWidth function functions are set for the target data, and specific function definitions are as follows:
Public void setWidth(int width){}
Public int getWidth(){}
through the steps, the design of the data carrier is completed, and the data is finally stored through the defined memory variables width and height. The above description shows the design of the set function and get function of width, and the design of the function for height is similar to width, and is not repeated here.
102. Setting a set function and a get function for target data;
103. using a Map data structure in the similar PKBean to design maintenance variables of global data;
it should be noted that Public void setWidth (int width) { } is a definition of a set function, and in this step, description will be given for implementation of the set function.
In the embodiment of the invention, a maintenance variable Map < S of global data is defined in the PKBean-like, Object > allinfo, when a caller calls the setWidth function, the caller first assigns a value to the global variable width through a variable of a statement this.
Wherein, a Map data structure is used to store data when designing the global set, wherein S represents the name of the stored data, and the generic Object type stores the specific information of the data. Since the Object type is an abstract class given to the top layer in Java and has the capability of receiving other types of data according to the Object-oriented characteristic, various types of data in the class PKBean can be stored in the set allInfo. Put the information of the setting parameter to the global set allinfo by calling the method of the set allinfo, and similarly, the storage processing is carried out on the set functions of other parameters in a similar way, that is, the data is cached to the global variable allinfo in the data storage logic in the data PKBean.
In addition, in practical application, the corresponding getWidth function may return the content information of the global variable width by calling the existing return this.
104. Defining a calibration set object listTarget in a PKBean-like model;
105. determining whether the allInfo lacks data information according to the listTarget;
it should be noted that, since a set function of a partial function may not be called in the conversion process, that is, not all parameter information is set, partial data may be lost, and thus an exception may occur in the service function. In view of this, the embodiment of the present invention adds a data checking function, which can effectively ensure the integrity of data, thereby avoiding the problem of data shortage. The specific implementation is as follows: 1) in order to verify field information in a PKBean object, a calibration set object listTarget is designed in the PKBean type object, and then the listTarget set object is initialized, wherein the specific initialization method is to initialize by calling a listTarget (newArrayList < String >); 2) then, a checkParam function is designed to realize the detection operation of the parameter information, and the specific function definition is as follows: public boilean checkParam () { }, it should be noted that, the checkParam function has no parameter and the factory parameter is a boilean boolean type variable, if the boilean boolean return value is true, it indicates that the check is passed, otherwise, it indicates that the check is not passed; 3) in the function checkParam, the listTarget is assigned, and a check object is added by calling a listtarget.add () function in the listTarget object, for example, if the widht information needs to be checked, the function listtarget.add ("width") can be realized by calling the listtarget.add function. It should be noted that, if length or other field information needs to be checked, addition may also be performed in a similar manner, and details are not described here; after the processing, the listTarget set contains all field information to be checked; 4) traversing the allInfo set objects in the scheme, sequentially extracting field information in the allInfo set objects, and marking the extracted field information as item; 5) judging whether the listTarget set contains the element information by calling a listtarget.contacts (item) function in the listTarget set object, and if so, removing the element information from the listTarget set by calling the listtarget.remove (item) function. If not, performing next cycle check; 6) when the whole allinfo set loop is finished, whether the listTarget object contains elements needs to be determined, specifically, the listTarget size () function is called. If the return value of the listtarget.size () function is 0, it indicates that all element information has been included, and if the return value of the listtarget.size () function is greater than 0, it indicates that there is some information that has not been removed from the listTarget object, i.e. part of information content is missing in the allinfo set, which indicates that the allinfo set lacks content, and a conversion process (tosting ()) cannot be performed, so that a false is returned, i.e. step 106 is performed; conversely, the value of listtarget. size () is 0, return true; 7) checking the check parameters of the scheme in a toString () function for conversion, and performing subsequent conversion operation if true is returned; otherwise, the conversion is stopped and an exception is thrown to prompt the developer that the conversion fails.
The automatic parameter checking function can be realized through the design, and the integrity of information in the conversion process is ensured.
106. When the allInfo comprises all data information, performing a conversion process through a to String () function;
107. and calling a PKBean and toString () function in the PKbean-like function to acquire the C + + message according to the String type object.
It should be noted that, in the prior art, the conversion method of the data bearer defines a special function to implement the conversion logic, and then calls the function to implement the conversion function. However, this approach may add too many function functions and is relatively troublesome to implement and design, and in view of this, the embodiment of the present invention provides a design flow of a conversion method for a data bearer, which specifically includes the following steps:
step 1, the embodiment of the present invention performs a conversion process by means of a tosting () function of the system when being implemented, it should be noted that, when the tosting () function is designed, it is used for printing some log information, and it is rare to use the tosting () function to perform logic processing, but because the tosting () function returns content information of a character string, and data of a C + + transfer message is also character string information, it can perfectly match, and based on this, the embodiment of the present invention can directly implement a true conversion process in the tosting () function of the system and output the conversion process.
In addition, in step 103, all the information is already stored in the global set allinfo, so that the conversion process can be realized only by acquiring the data information in the allinfo when the conversion is needed.
Step 2, it needs to be noted that in order to improve the conversion efficiency in the conversion process, in the embodiment of the present invention, a stripbuilder character string splicing type builder is designed when the conversion process is implemented, and the whole information conversion process is implemented through a stripbuilder object of the type of the builder, so that the generation of garbage variables in the conversion process can be reduced, and the memory overhead in the conversion process can be effectively reduced.
Specifically, a name prefix information "PKBean {" is added to the builder by calling an ap-pend ("PKBean {") function in the builder object, and then information is sequentially taken out from the allinfo set in a traversal manner and spliced. Alternatively, in practical application, the splicing method may be that value information of the width is obtained by calling an allinfo. After the above processing, the format of the data in the whole builder object is as follows:
PKBean{width＝widthValue。
and 3, adding the data information in the allinfo to the builder object, and packaging the data information. The specific adding method is that a separator is added first by calling the builder. allowed (",") function in the builder object, and then the information of length is added. It should be noted that the method for specifically adding the length information is similar to the method for adding the width information, and details are not described here.
And 4, when all the information is completely assembled, adding an end character, wherein the specific method for adding the end character is to add the end character by calling a builder. appended (") function in the builder object, so that the whole data information adding process is completed. The data composition form in the builder object at this time is as follows:
PKBean{width＝widthValue,length＝lengthValue}。
and 5, after the whole data information is completely encapsulated in the builder object, calling a builder _ testring () function to convert the data in the builder object into a String type object builder String, and then calling a return builder String function to return the builder String.
Therefore, in the subsequent use process, the final C + + message data can be obtained only by calling the pkbean and toString () functions of the pkbean object, so that the parameter information can be quickly obtained and the data can be transferred.
In the embodiment of the invention, a parameter list sent to the C + + bullet screen server can be quickly and effectively constructed through the implementation of the scheme. Compared with a splicing method for realizing bullet screen sending parameters one by one in a manual mode in the traditional scheme, the efficiency of parameter splicing, the speed of parameter splicing and the like can be greatly improved.
In addition, the embodiment shown in fig. 1 realizes the flow of data conversion, but there is a problem that when there are a plurality of field information width and length in a PKBean-like, the conversion process will automatically convert all data information. However, in practical applications, other relevant information may be stored in the PKBean-like server and the information does not need to be transferred to the C + + server, and the embodiment shown in fig. 1 cannot meet the requirement because the embodiment shown in fig. 1 performs all conversion processing on all the information. In view of this, the embodiment of the present invention provides a design method capable of changing the number of input parameters, and a specific implementation method includes the following steps: 1) the redesign is performed when designing the set function, and the specific design method is as follows: public void set width (int width, Boolean isArgment); public void length (int length, Boolean isrestriction), when designing the above function, a parameter information isrestriction is added in the set function, and the parameter information is a bootean Boolean variable information used for indicating whether to add the parameter information to the global variable allinfo. It will be appreciated that this operational flow needs to be performed in all set-series functions; 2) assigning a function parameter to a variable width by calling a this width function, and then judging the value information of isArgment, wherein if isArgment is equal to false, the parameter information does not need to be stored, and the parameter is parameter information which does not need to be transmitted to C + + at the moment, so that the capture processing can be carried out; if equal, it indicates that the parameter is the parameter information that needs to be transferred in C + +, so it needs to store the parameter information into the allinfo set by calling the allinfo. Similarly, if isArgment in other set functions is false, the parameter is not stored in the allInfo set, otherwise the information is stored in the set allInfo. Through the design, the content in the set allInfo is the content information needing to be stored, and the content needing not to be stored cannot be stored in the set allInfo; 3) since the allinfo set does not include all field information in the PKBean class, when acquiring the information, it is necessary to acquire key and value information one by one, and a specific manner of acquiring the key and value is as follows: acquiring an entryseet object entryseet of an allinfo object by calling an allinfo.entryseet () function of the allinfo object, then calling an entryseet.iter () method in the entryseet object to acquire an iterer type object miterer, judging whether element information exists in the allinfo object by calling an iterer.hasnext () method in the miterer object, and if a true is returned, indicating that the element information exists; otherwise, the result shows that the product is not; 4) if it is true, a key value pair information entry is first acquired by a map.entry (map.entry) it.next () function, and then key information is acquired by calling a String key (String) entry.getkey () function and the acquired key information mandatory type is converted into String type data. Similarly, the int value () function is called to obtain its value information and to force the type of the obtained value information to be converted into data of one int type. Thus, the key-value pair information can be obtained; 5) similar to the embodiment shown in fig. 1, the above-mentioned key value pair information is constructed into a C + + parameter object through the builder object, so that a target function that part of parameters need to be transferred in PKBean and part of parameters do not need to be transferred can be realized.
It should be noted that, in the implementation of the embodiment shown in fig. 1, a series of set functions are processed through the object of the PKBean class, which results in that the object of the PKBean class needs to be transferred in multiple places, and finally, the final conversion is implemented through the toString function of the object of the PKBean class. In order to solve the above problem, an embodiment of the present invention further provides a method for quickly constructing an object, and a specific implementation manner includes the following steps: 1) in order to realize the construction of data rapidly, a static MyBuilder class is designed in a PKBean class, and the specific definition method is as follows: public static class MyBuilder { }, it should be noted that this MyBuilder is an internal class of PKBean class and is a public authority static class, wherein the field information defined in this MyBuilder is completely consistent with the field information contained in PKBean. For example, in the embodiment shown in fig. 1, the PKBean class includes two pieces of field information, i.e., int width and int length, and then the two pieces of field information, i.e., int width and int length, are also defined in the internal class MyBuilder; 2) two set methods are defined in the internal MyBuilder, and the specific definition method is as follows: public MyBuilder setWidth (int Width); public MyBuilder setLength (int length); it should be noted that the set method has the biggest characteristic that the return value type is the type of an internal MyBuilder, and the design can conveniently continue to set the message after setting a piece of information; 3) in the public MyBuilder setWidth (int width) function, the width information is stored in the internal MyBuilder object by calling this, where this represents the internal MyBuilder class of PKBean, that is, the information is stored in the object of MyBuilder class. And directly returning the object of the MyBuilder type per se this by calling a rethrn this function after the storage is finished. Similarly, the design of the set function for length is similar to the set function for width, and a MyBuilder object is returned. Since the returned MyBuilder type object this is, the design has the advantages that after one piece of information is set, another piece of information can be set; 4) defining a builder function in the MyBuilder class, wherein the specific function definition is as follows: the method comprises the steps that a public PKBean is built () { }, the builder function returns an object of a PKBean type, and a conversion process of converting a MyBuilder class into a PKBean class is realized in the builder function, wherein the specific conversion process is that a PKBean object is constructed by calling a PKBean construction function, for example, a pkBean object is obtained by calling a PKBean () function, and then a pkBean is. Storing the information of the widht object in the MyBuilder object into the widht field of the returned pkBean object, thus completing the conversion of field information; 5) since the field information in the MyBuilder class and the field information in the PKBean class are identical in the initial design process, i.e., step 1), the MyBuilder class can be perfectly converted into the PKBean class object, and the conversion method of other fields is similar to the above description, so that a PKBean object is obtained. And then calling a pkbean.tostring () function in the pkbean object to convert the pkbean object into a parameter object required by C + +.
Embodiments of the present invention are described above from the perspective of a method of acquiring data, and embodiments of the present invention are described below from the perspective of an acquisition device.
The embodiments of the present invention are described above from the viewpoint of constructing a method of acquiring data, and the embodiments of the present invention are described below from the viewpoint of an acquisition apparatus.
Referring to fig. 2, fig. 2 is a schematic diagram of an embodiment of a possible obtaining apparatus according to an embodiment of the present invention, where the obtaining apparatus specifically includes:
a defining unit 201, configured to define target data in a class PKBean of a data Bean object, where the target data is a private type;
a setting unit 202, configured to set a set function and a get function for the target data;
the defining unit 201 is further configured to design, using a Map data structure, a maintenance variable Map < S of global data, where S is used to indicate a name of stored data, Object > allinfo, where the Object is used to indicate information of the stored data, and the allinfo is used to indicate a set storing various types of data in the class PKBean;
a storage unit 203, configured to store parameter information used for setting a global variable in the set function in the allinfo according to the Map data structure, and return content information of the global variable according to the get function;
the defining unit 201 is further configured to define a listTarget of a calibration set in the class PKBean, where the listTarget is used to perform verification processing on data in the class PKBean;
a determining unit 204, configured to determine whether the allinfo lacks data information according to the listTarget;
if not, performing a conversion process through a to String () function, wherein the to String () function is used for converting the data information in the allinfo into an object of a String type;
a calling unit 206, configured to call a PKBean, toString () function in the PKBean class, so as to obtain the C + + message according to the object of the String type.
Optionally, in some possible implementations, the determining unit 204 is specifically configured to: defining a checkParam function, wherein the checkParam function is used for carrying out detection operation; calling listtarget.add () in the listTarget to add a check object in the checkParam function; sequentially traversing and extracting data information in the allInfo, wherein the identification information of the data information is item; calling a listTarget-contacts (item) function in the listTarget to judge whether the listTarget contains the data information; if the data information is contained, removing the data information from the listTarget; if the data information is not contained, the cyclic check is continuously carried out; when the allInfo loop is finished, judging whether the listTarget has elements; if yes, determining that the allInfo lacks the information content; and if not, determining that the allInfo contains all information content.
Optionally, in some possible implementation manners, the target data includes width data of an int type and height data of an int type, and the setting unit 202 is specifically configured to: setting the functions of the set function and the get function according to the following manner: public void setWidth (int width) { }; public int getWidth () { }.
Optionally, in some possible implementation manners, the conversion unit 205 is specifically configured to: defining a builder object of a character string splicing class in the Stringbuilder type; calling a function ap (PKBean { ") in the builder object to add name prefix information (PKBean {") in the builder object; sequentially traversing and extracting data information in the allInfo; adding data information in the allinfo to the builder object, and packaging the data information; and after the data information in the allinfo is packaged in the builder object, calling a builder tostring () function to convert the data in the builder object into the String type object.
Optionally, in some possible implementation manners, the conversion unit 205 is specifically configured to: calling an allinfo.get (width) function to acquire value information width of the width data; get ("length") function to obtain Value information length Value of the length data.
Optionally, in some possible implementation manners, the conversion unit 205 is specifically configured to: calling an ap (width) function in the builder object to insert value information width of the width data in the builder object, so that the data in the builder object is composed of the following components: PKBean { width ═ width value; calling a builder () function in the builder object to add a delimiter; calling an end (length) function in the builder object, inserting value information (length) of the length data into the builder object, so that the data in the builder object is composed of the following components: PKBean { width ═ length; calling a builder () function in the builder object to add an end character to realize the encapsulation of the data information.
Optionally, in some possible implementations, the invoking unit 206 is further configured to: calling a returnbuilderStr function to return the object of the String type, wherein the builderStr is used for representing the object of the String type.
Referring to fig. 3, fig. 3 is a schematic diagram of an embodiment of an electronic device according to an embodiment of the invention.
As shown in fig. 3, an embodiment of the present invention provides an electronic device, which includes a memory 310, a processor 320, and a computer program 311 stored in the memory 320 and executable on the processor 320, where the processor 320 executes the computer program 311 to implement the following steps: defining target data in a PKBean class of a data Bean object, wherein the target data is a private type; setting a set function and a get function for the target data; using a Map data structure in the PKBean-like, designing a maintenance variable Map < S of global data, wherein S is used for representing the name of stored data, Object is used for representing the information of the stored data, and allinfo is used for representing the collection of various types of data stored in the PKBean-like; storing parameter information used for setting a global variable in the set function in the allInfo according to the Map data structure, and returning content information of the global variable according to the get function; defining a calibration set object listTarget in the class PKBean, wherein the listTarget is used for verifying data in the class PKBean; determining whether the allInfo lacks data information according to the listTarget; if not, performing a conversion process through a to String () function, wherein the to String () function is used for converting the data information in the allInfos into a String type object; and calling a PKBean and toString () function in the PKbean-like function to acquire the C + + message according to the String type object.
Optionally, in a possible embodiment, the processor 320 is specifically configured to: defining a checkParam function, wherein the checkParam function is used for carrying out detection operation; calling listtarget.add () in the listTarget to add a check object in the checkParam function; sequentially traversing and extracting data information in the allInfo, wherein the identification information of the data information is item; calling a listTarget-contacts (item) function in the listTarget to judge whether the listTarget contains the data information; if the data information is contained, removing the data information from the listTarget; if the data information is not contained, the cyclic check is continuously carried out; when the allInfo loop is finished, judging whether the listTarget has elements; if yes, determining that the allInfo lacks the information content; and if not, determining that the allInfo contains all information content.
Optionally, in a possible embodiment, the processor is specifically configured to: setting the functions of the set function and the get function according to the following manner: public void setWidth (int width) { }; public intgetWidth () { }.
Optionally, in a possible embodiment, the processor is specifically configured to: defining a builder object of a character string splicing class in the Stringbuilder type; calling a function ap (PKBean { ") in the builder object to add name prefix information (PKBean {") in the builder object; sequentially traversing and extracting data information in the allInfo; adding data information in the allinfo to the builder object, and packaging the data information; and after the data information in the allinfo is packaged in the builder object, calling a builder tostring () function to convert the data in the builder object into the String type object.
Optionally, in a possible embodiment, the processor is specifically configured to: calling an allinfo.get (width) function to acquire value information width of the width data; get ("length") function to obtain Value information length Value of the length data.
Optionally, in a possible embodiment, the processor is specifically configured to: calling an ap (width) function in the builder object to insert value information width of the width data in the builder object, so that the data in the builder object is composed of the following components: PKBean { width ═ width value; calling a builder () function in the builder object to add a delimiter; calling an end (length) function in the builder object, inserting value information (length) of the length data into the builder object, so that the data in the builder object is composed of the following components: PKBean { width ═ length; calling a builder () function in the builder object to add an end character to realize the encapsulation of the data information.
Optionally, in a possible embodiment, the processor is further configured to: calling a return builderStr function to return the object of the String type, wherein the builderStr is used for representing the object of the String type.
In a specific implementation, when the processor 320 executes the computer program 311, any of the embodiments corresponding to fig. 1 may be implemented.
Since the electronic device described in this embodiment is a device used for implementing one of the obtaining apparatuses in this embodiment of the present invention, based on the method described in this embodiment of the present invention, a person skilled in the art can understand the specific implementation manner of the electronic device in this embodiment and various variations thereof, so that how to implement the method in this embodiment of the present invention by the electronic device is not described in detail herein, and as long as the person skilled in the art implements the device used for implementing the method in this embodiment of the present invention, the device used for implementing the method in this embodiment of the present invention belongs to the protection scope of the present invention.
Referring to fig. 4, fig. 4 is a schematic diagram illustrating an embodiment of a computer-readable storage medium according to the present invention.
As shown in fig. 4, the present embodiment provides a computer-readable storage medium 400, on which a computer program 411 is stored, the computer program 411 implementing the following steps when executed by a processor: defining target data in a PKBean class of a data Bean object, wherein the target data is a private type; setting a set function and a get function for the target data; using a Map data structure in the PKBean-like, designing a maintenance variable Map < S of global data, wherein S is used for representing the name of stored data, Object is used for representing the information of the stored data, and allinfo is used for representing the collection of various types of data stored in the PKBean-like; storing parameter information used for setting a global variable in the set function in the allInfo according to the Map data structure, and returning content information of the global variable according to the get function; defining a calibration set object listTarget in the class PKBean, wherein the listTarget is used for verifying data in the class PKBean; determining whether the allInfo lacks data information according to the listTarget; if not, performing a conversion process through a to String () function, wherein the to String () function is used for converting the data information in the allInfos into a String type object; and calling a PKBean and toString () function in the PKbean-like function to acquire the C + + message according to the String type object.
Optionally, in a possible embodiment, the computer program 411 is specifically adapted to implement the following steps when being executed by a processor: defining a checkParam function, wherein the checkParam function is used for carrying out detection operation; calling listtarget.add () in the listTarget to add a check object in the checkParam function; sequentially traversing and extracting data information in the allInfo, wherein the identification information of the data information is item; calling a listTarget-contacts (item) function in the listTarget to judge whether the listTarget contains the data information; if the data information is contained, removing the data information from the listTarget; if the data information is not contained, the cyclic check is continuously carried out; when the allInfo loop is finished, judging whether the listTarget has elements; if yes, determining that the allInfo lacks the information content; and if not, determining that the allInfo contains all information content.
Optionally, in a possible embodiment, the computer program 411 is specifically adapted to implement the following steps when being executed by a processor: setting the functions of the set function and the get function according to the following manner: public voidsetWidth (int width) { }; public int getWidth () { }.
Optionally, in a possible embodiment, the computer program 411 is specifically adapted to implement the following steps when being executed by a processor: defining a builder object of a character string splicing class in the Stringbuilder type; calling a function ap (PKBean { ") in the builder object to add name prefix information (PKBean {") in the builder object; sequentially traversing and extracting data information in the allInfo; adding data information in the allinfo to the builder object, and packaging the data information; and after the data information in the allinfo is packaged in the builder object, calling a builder tostring () function to convert the data in the builder object into the String type object.
Optionally, in a possible embodiment, the computer program 411 is specifically adapted to implement the following steps when being executed by a processor: calling an allinfo.get (width) function to acquire value information width of the width data; get ("length") function to obtain Value information length Value of the length data.
Optionally, in a possible embodiment, the computer program 411 is specifically adapted to implement the following steps when being executed by a processor: calling an ap (width) function in the builder object to insert value information width of the width data in the builder object, so that the data in the builder object is composed of the following components: PKBean { width ═ width value; calling a builder () function in the builder object to add a delimiter; calling an end (length) function in the builder object, inserting value information (length) of the length data into the builder object, so that the data in the builder object is composed of the following components: PKBean { width ═ length; calling a builder () function in the builder object to add an end character to realize the encapsulation of the data information.
Optionally, in a possible embodiment, the computer program 411 is further configured to, when executed by the processor, implement the following steps: calling a return builderStr function to return the object of the String type, wherein the builderStr is used for representing the object of the String type.
It should be noted that, in the foregoing embodiments, the descriptions of the respective embodiments have respective emphasis, and reference may be made to relevant descriptions of other embodiments for parts that are not described in detail in a certain embodiment.
As will be appreciated by one skilled in the art, embodiments of the present invention may be provided as a method, system, or computer program product. Accordingly, the present invention may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present invention may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, and the like) having computer-usable program code embodied therein.
The present invention is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each flow and/or block of the flow diagrams and/or block diagrams, and combinations of flows and/or blocks in the flow diagrams and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, embedded computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including instruction means which implement the function specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide steps for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
While preferred embodiments of the present invention have been described, additional variations and modifications in those embodiments may occur to those skilled in the art once they learn of the basic inventive concepts. Therefore, it is intended that the appended claims be interpreted as including preferred embodiments and all such alterations and modifications as fall within the scope of the invention.
It will be apparent to those skilled in the art that various changes and modifications may be made in the present invention without departing from the spirit and scope of the invention. Thus, if such modifications and variations of the present invention fall within the scope of the claims of the present invention and their equivalents, the present invention is also intended to include such modifications and variations.
Claims (9)
1. A method for obtaining data, the method being used for obtaining a C + + message in an Android system, and comprising:
defining target data in a PKBean class of a data Bean object, wherein the target data is a private type;
setting a set function and a get function for the target data;
using a Map data structure in the PKBean-like, designing a maintenance variable Map < S of global data, wherein S is used for representing the name of stored data, Object is used for representing the information of the stored data, and allinfo is used for representing the collection of various types of data stored in the PKBean-like;
storing parameter information used for setting a global variable in the set function in the allInfo according to the Map data structure, and returning content information of the global variable according to the get function;
defining a calibration set object listTarget in the class PKBean, wherein the listTarget is used for verifying data in the class PKBean;
determining whether the allInfo lacks data information according to the listTarget;
if not, performing a conversion process through a to String () function, wherein the to String () function is used for converting the data information in the allInfos into a String type object;
and calling a PKBean and toString () function in the PKbean-like function to acquire the C + + message according to the String type object.
2. The method as claimed in claim 1, wherein said determining if said alllnfo lacks data information according to said listTarget comprises:
defining a checkParam function, wherein the checkParam function is used for carrying out detection operation;
calling listtarget.add () in the listTarget to add a check object in the checkParam function;
sequentially traversing and extracting data information in the allInfo, wherein the identification information of the data information is item;
calling a listTarget-contacts (item) function in the listTarget to judge whether the listTarget contains the data information;
if the data information is contained, removing the data information from the listTarget;
if the data information is not contained, the cyclic check is continuously carried out;
when the allInfo loop is finished, judging whether the listTarget has elements;
if yes, determining that the allInfo lacks the data information;
and if not, determining that the allInfo contains all data information.
3. The method of claim 1, wherein the target data comprises int-type width data and int-type height data;
the function of setting a set function and the function of a get function on the target data comprise:
setting the functions of the set function and the get function according to the following manner:
Public void setWidth(int width){}；
Public int getWidth(){}。
4. the method of claim 3, wherein the converting process by the to String () function comprises:
defining a builder object of a character string splicing class in the Stringbuilder type;
calling a function ap (PKBean { ") in the builder object to add name prefix information (PKBean {") in the builder object;
sequentially traversing and extracting data information in the allInfo;
adding data information in the allinfo to the builder object, and packaging the data information;
and after the data information in the allinfo is packaged in the builder object, calling a builder tostring () function to convert the data in the builder object into the String type object.
5. The method as claimed in claim 4, wherein said sequentially traversing and extracting the data information in the alllnfo comprises:
calling an allinfo.get (width) function to acquire value information width of the width data;
get ("length") function to obtain the value information length of the length data.
6. The method as claimed in claim 5, wherein the adding the data information in the allinfo to the builder object and encapsulating the data information comprises:
calling an ap (width =) function in the builder object, and inserting value information width of the width data in the builder object by using an ap (width =) function so that the data in the builder object is composed of the following components: PKBean { width = width value;
calling a builder () function in the builder object to add a delimiter;
an open ("length =") function in the builder object is called, and an open (length value) function inserts value information length value of the length data into the builder object, so that the data in the builder object is composed of the following components: PKBean { width = width, length = length;
calling a builder () function in the builder object to add an end character to realize the encapsulation of the data information.
7. The method according to any one of claims 1 to 6, wherein after the conversion process by the to String () function, before the calling a PKBean, a to String () function in the class PKBean to obtain the C + + message according to the String type object, the method further comprises:
calling a return builderStr function to return the object of the String type, wherein the builderStr is used for representing the object of the String type.
8. An obtaining apparatus, configured to obtain a C + + message in an Android system, comprising:
the defining unit is used for defining target data in a PKBean class of a data Bean object, wherein the target data is a private type;
the setting unit is used for setting a set function and a get function for the target data;
the defining unit is further used for designing a maintenance variable Map < S of global data by using a Map data structure in the class PKBean, wherein S is used for representing the name of stored data, Object is used for representing information of the stored data, and allinfo is used for representing a set for storing various types of data in the class PKBean;
the storage unit is used for storing the parameter information used for setting the global variable in the set function in the allInfo according to the Map data structure and returning the content information of the global variable according to the get function;
the defining unit is further configured to define a listTarget of a calibration set in the class PKBean, where the listTarget is used to perform verification processing on data in the class PKBean;
a determining unit, configured to determine whether the allinfo lacks data information according to the listTarget;
if not, performing a conversion process through a to String () function, wherein the to String () function is used for converting the data information in the allinfo into an object of a String type;
and the calling unit is used for calling the PKBean and toString () functions in the PKbeans of the class so as to acquire the C + + message according to the objects of the String type.
9. A computer-readable storage medium comprising instructions that, when executed on a computer, cause the computer to perform the method of any of claims 1-7.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201810872389.7A CN109343968B (en) | 2018-08-02 | 2018-08-02 | Method and related device for acquiring data |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201810872389.7A CN109343968B (en) | 2018-08-02 | 2018-08-02 | Method and related device for acquiring data |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN109343968A CN109343968A (en) | 2019-02-15 |
| CN109343968B true CN109343968B (en) | 2020-09-04 |
Family
ID=65291343
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201810872389.7A Active CN109343968B (en) | 2018-08-02 | 2018-08-02 | Method and related device for acquiring data |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN109343968B (en) |
Families Citing this family (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN109992581B (en) * | 2019-02-20 | 2023-05-26 | 平安科技（深圳）有限公司 | HashMap-based data acquisition method and device, computer equipment and storage medium |
| CN113835717A (en) * | 2020-06-23 | 2021-12-24 | 武汉斗鱼鱼乐网络科技有限公司 | Installation package obtaining method, device, equipment and storage medium |
Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101650712A (en) * | 2009-08-18 | 2010-02-17 | 深圳市科陆电子科技股份有限公司 | Generating management method and system of self-defined report |
| CN106973332A (en) * | 2017-03-10 | 2017-07-21 | 武汉斗鱼网络科技有限公司 | A kind of barrage message treatment method, analytic method and system |
Family Cites Families (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| DE112012002774T5 (en) * | 2011-07-01 | 2014-03-20 | Stoneware Inc. | Method and device for a keep-alive push agent |
-
2018
- 2018-08-02 CN CN201810872389.7A patent/CN109343968B/en active Active
Patent Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101650712A (en) * | 2009-08-18 | 2010-02-17 | 深圳市科陆电子科技股份有限公司 | Generating management method and system of self-defined report |
| CN106973332A (en) * | 2017-03-10 | 2017-07-21 | 武汉斗鱼网络科技有限公司 | A kind of barrage message treatment method, analytic method and system |
Non-Patent Citations (1)
| Title |
|---|
| "基于MVC开发模式的在线学习互动平台设计与实现";贾卫峰等;《软件导刊》;20171031;全文 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN109343968A (en) | 2019-02-15 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN110275831B (en) | Mock data verification method and device of protocol interface | |
| CN107704382A (en) | Towards Python function call path generating method and system | |
| CN109343968B (en) | Method and related device for acquiring data | |
| CN111343181B (en) | Message processing method and system, data pool and computer readable storage medium | |
| CN108572911A (en) | Automate safety detecting method, device, electronic equipment and readable storage medium storing program for executing | |
| CN112037061A (en) | Processing method and device for transactions in block chain, electronic equipment and storage medium | |
| CN108469955B (en) | Annotation-based Android injection framework implementation method | |
| CN104866764B (en) | A kind of Android phone malware detection method based on object reference figure | |
| CN111679979B (en) | Destructive testing method and device | |
| CN111367818A (en) | System component testing method and device based on dynamic data return | |
| CN110659905A (en) | Transaction verification method, device, terminal equipment and storage medium | |
| CN110598419B (en) | Block chain client vulnerability mining method, device, equipment and storage medium | |
| CN111078573A (en) | Test message generation method and device | |
| CN113704126B (en) | Verification method and device thereof, computer storage medium and processor | |
| CN114896161A (en) | File construction method and device based on artificial intelligence, computer equipment and medium | |
| CN111240772A (en) | Data processing method and device based on block chain and storage medium | |
| CN117370203B (en) | Automatic test method, system, electronic equipment and storage medium | |
| CN110795169B (en) | Method and related device for acquiring data | |
| CN110795168B (en) | Method for acquiring data and related device | |
| CN110795098B (en) | Method and related device for acquiring data | |
| CN107783760B (en) | Visual development method for protection device based on functional component | |
| CN116821119A (en) | Method, device and server for generating message analysis code | |
| CN113608746B (en) | Code conversion processing method, device, computer equipment and storage medium | |
| CN111275553B (en) | Block chain data storage method and block chain system | |
| US10726109B2 (en) | Method and system for identifying whether an application is genuine by means of digital watermarks |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant | ||
| TR01 | Transfer of patent right |
Effective date of registration: 20240611 Address after: Room 106, 1st Floor, Building 28, No. 99 Beigao Road, Shunyi District, Beijing, 101300 Patentee after: Beijing Tianchuang Jinqiao Technology Service Co.,Ltd. Country or region after: China Address before: 430000 East Lake Development Zone, Wuhan City, Hubei Province, No. 1 Software Park East Road 4.1 Phase B1 Building 11 Building Patentee before: WUHAN DOUYU NETWORK TECHNOLOGY Co.,Ltd. Country or region before: China |
|
| TR01 | Transfer of patent right |