CN113448550B - Method and device for realizing collection management of classes, electronic equipment and computer medium - Google Patents
Method and device for realizing collection management of classes, electronic equipment and computer medium Download PDFInfo
- Publication number
- CN113448550B CN113448550B CN202010219123.XA CN202010219123A CN113448550B CN 113448550 B CN113448550 B CN 113448550B CN 202010219123 A CN202010219123 A CN 202010219123A CN 113448550 B CN113448550 B CN 113448550B
- Authority
- CN
- China
- Prior art keywords
- class
- annotation
- implementation
- implementation class
- container
- 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
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/31—Programming languages or programming paradigms
- G06F8/315—Object-oriented languages
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
- G06F8/73—Program documentation
-
- 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/44—Arrangements for executing specific programs
- G06F9/448—Execution paradigms, e.g. implementations of programming paradigms
- G06F9/4488—Object-oriented
- G06F9/449—Object-oriented method invocation or resolution
-
- 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/44—Arrangements for executing specific programs
- G06F9/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
- G06F9/45533—Hypervisors; Virtual machine monitors
- G06F9/45558—Hypervisor-specific management and integration aspects
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Computing Systems (AREA)
- Library & Information Science (AREA)
- Stored Programmes (AREA)
- Devices For Executing Special Programs (AREA)
Abstract
The embodiment of the disclosure provides a collection management method, a device, electronic equipment and a computer medium for realizing class, comprising the following steps: marking the implementation class of the interface through a first annotation; marking the container class of the interface through a second annotation; at compile time, the implementation class of the interface is populated into the container class of the interface based on the first annotation and the second annotation. In the embodiment of the disclosure, the first annotation marks the interface to which the implementation class belongs and the second annotation marks the implementation class of which interface the container class is used for collecting, so that decoupling between the implementation class and the container class is realized, and further, when compiling, the implementation class is filled into the container class based on the first annotation and the second annotation, and the maintenance cost is reduced without manually adding the corresponding implementation class or adding the corresponding implementation class in a constructor of the container class.
Description
Technical Field
The disclosure relates to the technical field of computers, and in particular relates to a collection management method, a device, electronic equipment and a computer medium for realizing class.
Background
In actual traffic, there are many traffic that implement the class collection aspect, such as the business/channel registration of long connections is filled into Manager (container class), the received message is registered into container class, etc. There are two ways to fill and register the implementation classes in the existing way, one is to add each implementation class to the management class through the interface, and one is that each implementation class is registered in the container class. However, the two approaches described above have two drawbacks: first, there is no decoupling between the container class and the implementation classes, i.e., the container class needs to know which implementation classes are present. Second, implementation classes that typically need to be collected are distributed among the various modules or components, and if one wants to register an implementation class into a container class, one needs to write a specific implementation class in a constructor of the container class, where there is a maintenance cost to code that fills the implementation class.
Disclosure of Invention
This summary is provided to introduce a selection of concepts in a simplified form that are further described below in the detailed description. This summary is not intended to identify key features or essential features of the claimed subject matter, nor is it intended to be used to limit the scope of the claimed subject matter.
In a first aspect, an embodiment of the present disclosure provides a collection management method for implementation classes, where the method includes:
marking the implementation class of the interface through a first annotation;
marking the container class of the interface through a second annotation;
at compile time, the implementation class of the interface is populated into the container class of the interface based on the first annotation and the second annotation.
In a second aspect, an embodiment of the present disclosure provides a collection management apparatus for implementing classes, including:
the marking module is used for marking the implementation class of the interface through the first annotation and marking the container class of the interface through the second annotation;
and the filling module is used for filling the implementation class of the interface into the container class of the interface based on the first annotation and the second annotation when compiling.
In a third aspect, the present disclosure provides an electronic device comprising a processor and a memory;
a memory for storing computer operating instructions;
a processor for executing the method as shown in any of the embodiments of the first aspect of the present disclosure by invoking computer operating instructions.
In a fourth aspect, the present disclosure provides a computer readable medium storing at least one instruction, at least one program, code set, or instruction set, the at least one instruction, at least one program, code set, or instruction set being loaded and executed by a processor to implement a method as shown in any of the embodiments of the first aspect of the present disclosure.
The technical scheme provided by the embodiment of the disclosure has the beneficial effects that:
in the embodiment of the disclosure, the implementation class and the container class of the interface can be marked by means of the first annotation and the second annotation respectively, and further, when compiling, the first annotation marks the interface to which the implementation class belongs and the second annotation marks the implementation class of which interface the container class is used for collecting, so that decoupling between the implementation class and the container class is realized, and when compiling, the implementation class is filled into the container class based on the first annotation and the second annotation, and the corresponding implementation class is not required to be manually added or added in a constructional function of the container class, so that maintenance cost is reduced.
Drawings
The above and other features, advantages, and aspects of embodiments of the present disclosure will become more apparent by reference to the following detailed description when taken in conjunction with the accompanying drawings. The same or similar reference numbers will be used throughout the drawings to refer to the same or like elements. It should be understood that the figures are schematic and that elements and components are not necessarily drawn to scale.
FIG. 1 is a flow chart of a method for implementing collection management of classes in an embodiment of the disclosure;
FIG. 2 is a schematic structural diagram of a collection management device of an implementation class in an embodiment of the disclosure;
fig. 3 is a schematic structural diagram of an electronic device according to an embodiment of the disclosure.
Detailed Description
Embodiments of the present disclosure will be described in more detail below with reference to the accompanying drawings. While certain embodiments of the present disclosure have been shown in the accompanying drawings, it is to be understood that the present disclosure may be embodied in various forms and should not be construed as limited to the embodiments set forth herein, but are provided to provide a more thorough and complete understanding of the present disclosure. It should be understood that the drawings and embodiments of the present disclosure are for illustration purposes only and are not intended to limit the scope of the present disclosure.
It should be understood that the various steps recited in the method embodiments of the present disclosure may be performed in a different order and/or performed in parallel. Furthermore, method embodiments may include additional steps and/or omit performing the illustrated steps. The scope of the present disclosure is not limited in this respect.
The term "including" and variations thereof as used herein are intended to be open-ended, i.e., including, but not limited to. The term "based on" is based at least in part on. The term "one embodiment" means "at least one embodiment"; the term "another embodiment" means "at least one additional embodiment"; the term "some embodiments" means "at least some embodiments. Related definitions of other terms will be given in the description below.
It should be noted that the terms "first," "second," and the like in this disclosure are used merely to distinguish one from another device, module, or unit, and are not intended to limit the device, module, or unit to the particular device, module, or unit or to limit the order or interdependence of functions performed by the devices, modules, or units.
It should be noted that references to "one", "a plurality" and "a plurality" in this disclosure are intended to be illustrative rather than limiting, and those of ordinary skill in the art will appreciate that "one or more" is intended to be understood as "one or more" unless the context clearly indicates otherwise.
The names of messages or information interacted between the various devices in the embodiments of the present disclosure are for illustrative purposes only and are not intended to limit the scope of such messages or information.
Embodiments of the present disclosure provide a collection management method for implementation classes, as shown in fig. 1, where the method may include:
in step S110, the implementation class of the interface is marked through the first annotation.
Step S120, marking the container class of the interface through the second annotation.
Interfaces, are one of the important concepts in Java, are a collection of abstract methods, interfaces are usually declared by interfaces, interfaces cannot be directly instantiated, but an Interface can point to its implementation class object. The specification is defined in an interface, and the implementation class determines how the specification operates, that is, a specific implementation method of the interface, and one interface may have one or more implementation classes. For example, an interface a defines a "eat" method, the implementation class is given a specific implementation of "eat", for example, an A1 and A2 implement an interface a, A1 is "eat" and A2 is "eat fish", then A1 and A2 are implementation classes of the interface a, when the "eat" method needs to be called, the implementation class of the interface a is called, that is, an A1 is instantiated (new), if all the "eat" methods need to be called, the interface a needs to be called, and the call of all the implementation classes of the interface a is realized through the interface a.
The container class is a management class and is used for realizing the management of all the implementation classes of the interfaces, one container class corresponds to one interface, in order to realize the collection (namely the management) of all the implementation classes of the interfaces, each implementation class needing to be called can be marked by a first annotation, and at the moment, the implementation class of which interface each implementation class is can be known based on the annotation; similarly, for each container class, it is possible to know, through the second annotation tag, based on the annotation, which interface implementation class each container class needs to invoke.
The implementation manner of marking the implementation class of the interface through the first annotation and marking the container class of the interface through the second annotation is not limited in the embodiment of the disclosure. For example, when the implementation class of the interface is marked through the first annotation, the implementation class of the interface can be marked in a mode of @ Register annotation, @ IntKeyregister or @ StringKeyregister annotation and the like; when the container class of the interface is marked through the second annotation, the container class of the interface can be marked in a @ provider annotation mode.
Step S120, at compile time, based on the first annotation and the second annotation, populating the implementation class of the interface into the container class of the interface.
In practical application, the implementation class marks the corresponding interface through the first annotation, and the container class marks the corresponding interface through the second annotation, so that the implementation class can be known by the first annotation and the second annotation, and if the interfaces marked by the implementation class and the container class are the same interface, all the implementation classes of the interfaces corresponding to the implementation class can be collected by the container class based on the first annotation and the second annotation during compiling.
In an example, for an implementation class testimplel of List storage type, which is an implementation class of the ITest interface, the implementation class may be marked by @ Register annotation, and a specific marking manner may be:
@Register(target＝ITest.class)
public class TestImpl implements ITest{
}
further, since the container class Testmanager needs to collect all implementation classes of the Test interface, the container class Testmanager corresponding to the ITest interface may be marked by @ provider annotation, and a specific marking manner may be:
@Plunder(target＝ITest.class)
public class TestManager{
}
accordingly, after the class marking is implemented on the container class corresponding to the ITest, the implementation class marked as the ITest can be filled into the container class marked as the ITest during compiling.
In the embodiment of the disclosure, the implementation class and the container class of the interface can be marked by means of the first annotation and the second annotation respectively, and further, when compiling, the first annotation marks the interface to which the implementation class belongs and the second annotation marks the implementation class of which interface the container class is used for collecting, so that decoupling between the implementation class and the container class is realized, and when compiling, the implementation class is filled into the container class based on the first annotation and the second annotation, and the corresponding implementation class is not required to be manually added or added in a constructional function of the container class, so that maintenance cost is reduced.
In the embodiment of the present disclosure, for any implementation class, the implementation class is an implementation class of List (List) storage type or an implementation class of KV storage type stored in a mapping table in a K-V (key-value) storage manner, where K is an identifier of the implementation class and V is an instance of the implementation class;
marking the implementation class of the interface through a first annotation, comprising:
and marking the implementation class of the interface by adopting a first annotation corresponding to the storage type of the implementation class.
In practical application, two storage modes exist for the implementation class, and for any implementation class, the storage type of the implementation class can be stored in a List mode or in a K-V storage mode. Further, when the implementation class is stored by adopting different storage types, when the implementation class of the interface is marked by the first annotation, the first annotation corresponding to the storage type of the implementation class can be adopted to mark the implementation class of the interface.
For example, when the storage type of the implementation class is a List storage mode, the first annotation corresponding to the List storage mode may be used to mark the implementation class of the interface, for example, the @ Register annotation is used to mark the implementation class of the interface; when the storage type of the implementation class is KV storage type, the first annotation corresponding to KV storage type can be adopted to mark the implementation class of the interface, such as the @ StringKeyRegister (key of String type) annotation or @ IntKeyRegister (key of Int type) annotation is adopted to mark the implementation class of the interface.
In an embodiment of the present disclosure, the method further includes:
declaring the storage space of the container class and initializing the function;
at compile time, based on the first annotation and the second annotation, populating an implementation class of the interface into a container class of the interface, comprising:
determining the corresponding relation between the implementation class and the container class based on the first annotation and the second annotation;
and at compiling, filling the implementation class into the storage space of the container class by calling the initialization function based on the corresponding relation.
In practical application, the data storage type of the storage space corresponds to the storage type of the implementation class stored in the storage space, when the storage type of the implementation class stored in the storage space is a List storage type, the data storage type of the storage space should also be a List storage type, and when the storage type of the implementation class stored in the storage space is a KV storage type, the data storage type of the storage space should also be a KV storage type.
Further, the storage space of the container class and the initialization function may be declared, wherein when declaring the storage space of the container class, the manner of declaring needs to correspond to the storage type of the storage space. For example, when the storage type of the storage space is a List storage type, the manner of declaring the storage space of the container class may be to mark the container class with @ ListContainer annotation (corresponding to the List storage type), and to mark the initializing function of the container with @ ListStorage annotation (corresponding to the List storage type), which may be specifically:
@ListContainer
private List<ITest>list＝new ArrayList<>()；
@ListStorage
private void initList(){
//support this way
//list＝new ArrayList<>()；
When the storage type of the storage space is KV storage type, the manner of declaring the storage space of the container class may be: private Map < String, ITestMap > map=new HashMap < (), which corresponds to KV storage type; private void initList ()'s can be employed when declaring the initialization function of the container class; public ITestMap getTestMap (String value).
Further, when the implementation class of the interface is filled into the container class at compiling, the corresponding relation between the implementation class and the container class can be determined based on the first annotation and the second annotation, namely, which implementation class is collected by which container class, namely, which implementation class is filled into which container class; further, in practical applications, the storage space of the container class can be visually understood as a bottle, and the initializing function of the container class can be understood as an inlet of the bottle, and at this time, the implementation class is collected into the bottle through the inlet of the bottle, that is, the implementation class is collected into the storage space of the container class through the initializing function.
In an embodiment of the present disclosure, the method further includes:
marking the storage space of the container class through a third annotation, and marking the initializing function of the container class through a fourth annotation;
Wherein the third annotation marks the data storage type of the storage space and the fourth annotation marks the initialization function for filling the implementation class of the interface into the storage space.
In practical application, since the data storage type of the storage space of the container class corresponds to the storage type of the implementation class stored in the storage space, the storage type of the implementation class has a List storage type and a KV storage type, at this time, the data storage type of the storage space of the container class also has a List storage type and a KV storage type, and in order to know the storage type of the storage space of the container class, at this time, the storage space of the container class may be marked by a third annotation mode. For example, when the storage type of the storage space of the container class is a List storage type, the storage space of the container class may be marked with @ ListContainer annotation, and when the storage type of the storage space of the container class is a KV storage type, the storage space of the container class may be marked with @ KvContainer annotation.
Further, the initializing function of the container class may be marked in a fourth annotation mode, where the fourth annotation indicates that the initializing function is used to fill the implementation class of the interface into the storage space, and when the storage types of the storage spaces of the container class are different, the marking mode of the fourth annotation is different, for example, when the storage type is a List storage type, the fourth annotation may be @ ListStorag, and when the storage type is a KV storage type, the fourth annotation may be @ KvStorag.
In an embodiment of the present disclosure, at compile time, filling an implementation class of an interface into a container class of the interface includes:
if the implementation class of the interface is the implementation class of the List storage type, filling the instance of the implementation class into the storage space of the container class;
and if the implementation class of the interface is the implementation class of the KV storage type, filling K of the implementation class in the mapping table into the storage space of the container class.
In practical applications, when the implementation classes of the interface are different storage types, the way in which the implementation classes are filled into the storage space of the container class by calling the initialization function at compile time is also different. If the implementation class of the interface is an implementation class of the List storage type, an instance of the implementation class (i.e. new one of the objects of the implementation class) can be generated by calling a corresponding initialization function, and then the instance of the implementation class is directly filled into the storage space of the corresponding container class; when the implementation class of the interface is the implementation class of the KV storage type, at this time, K corresponding to the implementation class (that is, an object of the implementation class) may be determined in the mapping table, and then K corresponding to the implementation class is filled into the storage space of the container class by calling a corresponding initialization function.
In the embodiment of the present disclosure, for an implementation class of a List storage type, if a constructor of the implementation class is a private function, when marking a container class of an interface through a second annotation, the method further includes;
The instance of the realization class is declared to obtain the function, and the function is marked through a fifth annotation, and the fifth annotation marks the realization class of which the realization class is a single instance;
filling an instance of the implementation class into a storage space of the container class by calling an initialization function, comprising:
and filling the instance class obtaining function of the implementation class into the storage space of the container class by calling the initializing function.
In practical application, the constructors of the implementation classes can be divided into private functions and public functions, the implementation classes can be divided into single-instance implementation classes and non-single-instance implementation classes, wherein the single-instance implementation classes can be instantiated only once to generate one instance, and the non-single-instance implementation classes can be instantiated multiple times to generate multiple instances.
Further, for the implementation class of the List storage type, if the constructor of the implementation class is a private function, when the container class of the interface is marked through the second annotation, an instance obtaining function (such as getin state ()) of the implementation class needs to be declared, and the implementation class is marked as a single-instance implementation class by adopting a fifth annotation mode. Accordingly, when an instance of an implementation class is filled into the storage space of a container class by calling an initialization function, an implementation class obtaining function of the implementation class may be filled into the storage space of the container class.
In the embodiment of the present disclosure, for an implementation class of a KV storage type, if the implementation class can be instantiated only once, marking an initialization function of a container class through a fourth annotation includes:
if the implementation class is a single-instance implementation class, marking an initialization function of the container class through a fourth annotation, and transmitting a first annotation parameter when marking, wherein the first annotation parameter marks the implementation class that the implementation class is a single-instance implementation class;
if the implementation class is a non-single implementation class, marking an initialization function of the container class through a fourth annotation, and transmitting a second annotation parameter when marking, wherein the second annotation parameter indicates that the implementation class can be instantiated only once.
In practical application, when marking the KV type container class through @ provider annotation @ provider, code woven by @ provider on the KV type container function will recreate an instance at each call, but often this does not meet our business requirement, and the registered class (i.e. implementation class) is a single instance in most scenarios. And whether the implementation class is a single case or not has two control angles, one is that the container class is controlled, and the other is that the registered class is controlled.
The registered class control refers to that the registered class itself provides a single instance outwards, so that when the class is implemented by using the @ KeyStorage annotation tag, a first annotation parameter isSingleton=false can be input: the controlled by the container class means that the registered class does not provide a single instance to the outside and needs to be marked and modified by itself. If @ KvContainer is used to annotate the markup container class, then a second annotation parameter issingleton=true may be entered when @ KeyStorage is used to tag the initialization function of the container class, indicating that the implementation class can only be instantiated once.
In the embodiment of the present disclosure, for an implementation class of a KV storage type, if the implementation class can only be instantiated once, filling K of the implementation class in a mapping table into a storage space of a container class during compiling, including:
and when compiling, obtaining K of the implementation class in the mapping table by calling the initialization function, generating V of the implementation class, and filling the K and V of the implementation class into the storage space of the container class.
In practical application, for an implementation class of a KV storage type, the implementation class can be instantiated only once, at this time, after K of the implementation class in a mapping table is obtained based on calling an initialization function, V of the implementation class can be generated, then K and V of the implementation class are filled into a storage space of a container class, at this time, the storage space stores a mapping relation between K and V of the implementation class, and correspondingly, V of the implementation class can be obtained based on K of the implementation class.
In an embodiment of the present disclosure, the method further includes:
when a call request for a container class with a storage space of a List storage type is received, calling an instance of each implementation class in the storage space of the container class based on the call request;
when a call request aiming at a container class with a storage space of K-V storage type is received, searching corresponding V in the storage space of the container class based on K contained in the call request, calling the searched V if the corresponding V is found, and generating an instance of an implementation class corresponding to K and calling if the corresponding V is not found.
In practical application, when the implementation class of the container class needs to be called, a call request of the container class can be received at this time, and then the implementation class in the storage space of the container class is called based on the call request of the received container class. Wherein when the storage types of the storage spaces are different, the manner of calling the implementation class in the storage space of the container class is also different.
When a call request for a container class with a storage space of a List storage type is received, the instance of each implementation class in the storage space of the container class can be called at the moment, namely all the instances of the implementation classes in the storage space of the container class are called; when a call request for a container class with a storage space of KV storage type is received, K of an implementation class to be called is further included in the call request, at this time, a corresponding V can be searched in the storage space of the container class based on K contained in the call request, if V corresponding to the contained K is searched, the searched V is called, and if V corresponding to the contained K is not searched, at this time, an instance of the implementation class corresponding to the K can be generated and called.
In addition, when the storage type is KV, if K is a variable, the variable can be marked in a @ Key annotation mode, but note that different values in the variable are required to be stored in a list mode.
Based on the same principle as the method shown in fig. 1, there is also provided in an embodiment of the present disclosure a collection management device 30 of an implementation class, and as shown in fig. 2, the collection management device 30 of an implementation class may include a marking module 310 and a filling module 320, where:
a marking module 310, configured to mark an implementation class of the interface through a first annotation, and mark a container class of the interface through a second annotation;
the filling module 320 is configured to fill the implementation class of the interface into the container class of the interface based on the first annotation and the second annotation at compiling time.
In an optional embodiment of the disclosure, for any implementation class, the implementation class is an implementation class of List storage type or an implementation class of KV storage type stored in a mapping table by adopting a K-V storage mode, where K is an identifier of the implementation class and V is an instance of the implementation class;
the marking module is specifically used for marking the implementation class of the interface through a first annotation:
and marking the implementation class of the interface by adopting a first annotation corresponding to the storage type of the implementation class.
In an alternative embodiment of the disclosure, the apparatus further comprises a declaration module for:
declaring the storage space of the container class and initializing the function;
The filling module is used for filling the implementation class of the interface into the container class of the interface based on the first annotation and the second annotation during compiling, and is specifically used for:
determining the corresponding relation between the implementation class and the container class based on the first annotation and the second annotation;
and at compiling, filling the implementation class into the storage space of the container class by calling the initialization function based on the corresponding relation.
In an alternative embodiment of the present disclosure, the marking module is further configured to:
marking the storage space of the container class through a third annotation, and marking the initializing function of the container class through a fourth annotation;
wherein the third annotation marks the data storage type of the storage space and the fourth annotation marks the initialization function for filling the implementation class of the interface into the storage space.
In an alternative embodiment of the disclosure, the filling module is specifically configured to, when compiling the implementation class into the storage space of the container class:
if the implementation class of the interface is the implementation class of the List storage type, filling the instance of the implementation class into the storage space of the container class;
and if the implementation class of the interface is the implementation class of the KV storage type, filling K of the implementation class in the mapping table into the storage space of the container class.
In an optional embodiment of the disclosure, for an implementation class of the List storage type, if a constructor of the implementation class is a private function, the marking module is further configured to, when marking a container class of the interface through the second annotation;
the instance of the realization class is declared to obtain the function, and the function is marked through a fifth annotation, and the fifth annotation marks the realization class of which the realization class is a single instance;
the filling module is specifically configured to, when the instance of the implementation class is filled into the storage space of the container class by calling the initialization function:
and filling the implementation class obtaining function of the implementation class into the storage space of the container class by calling the initializing function.
In an optional embodiment of the disclosure, for an implementation class of a KV storage type, if the implementation class can be instantiated only once, the marking module is specifically configured to:
if the implementation class is a single-instance implementation class, marking an initialization function of the container class through a fourth annotation, and transmitting a first annotation parameter when marking, wherein the first annotation parameter marks the implementation class that the implementation class is a single-instance implementation class;
if the implementation class is a non-single implementation class, marking an initialization function of the container class through a fourth annotation, and transmitting a second annotation parameter when marking, wherein the second annotation parameter indicates that the implementation class can be instantiated only once.
In an optional embodiment of the present disclosure, for an implementation class of a KV storage type, if the implementation class can only be instantiated once, when the filling module fills K of the implementation class in the mapping table into a storage space of a container class during compiling, the filling module is specifically configured to:
and when compiling, obtaining K of the implementation class in the mapping table by calling the initialization function, generating V of the implementation class, and filling the K and V of the implementation class into the storage space of the container class.
In an alternative embodiment of the disclosure, the apparatus further includes a calling module configured to:
when a call request for a container class with a storage space of a List storage type is received, calling an instance of each implementation class in the storage space of the container class based on the call request;
when a call request aiming at a container class with a storage space of K-V storage type is received, searching corresponding V in the storage space of the container class based on K contained in the call request, calling the searched V if the corresponding V is found, and generating an instance of an implementation class corresponding to K and calling if the corresponding V is not found.
The collection management device for implementing the class in the embodiments of the present disclosure may perform a collection management method for implementing the class provided by the embodiments of the present disclosure, where the implementation principle is similar, and actions performed by each module in the collection management device for implementing the class in each embodiment of the present disclosure correspond to steps in the collection management method for implementing the class in each embodiment of the present disclosure, and detailed functional descriptions of each module in the collection management device for implementing the class may be specifically referred to descriptions in the corresponding collection management method for implementing the class shown in the foregoing, which are not repeated herein.
Based on the same principles as the methods shown in the embodiments of the present disclosure, there is also provided in the embodiments of the present disclosure an electronic device that may include, but is not limited to: a processor and a memory; a memory for storing computer operating instructions; and the processor is used for executing the method shown in the embodiment by calling the computer operation instruction.
Based on the same principle as the method shown in the embodiments of the present disclosure, there is also provided a computer readable storage medium storing at least one instruction, at least one program, a code set, or an instruction set, where the at least one instruction, the at least one program, the code set, or the instruction set is loaded and executed by a processor to implement the method shown in the above embodiments, which is not repeated herein.
Referring now to fig. 3, a schematic diagram of an electronic device 600 suitable for use in implementing embodiments of the present disclosure is shown. The terminal devices in the embodiments of the present disclosure may include, but are not limited to, mobile terminals such as mobile phones, notebook computers, digital broadcast receivers, PDAs (personal digital assistants), PADs (tablet computers), PMPs (portable multimedia players), in-vehicle terminals (e.g., in-vehicle navigation terminals), and the like, and stationary terminals such as digital TVs, desktop computers, and the like. The electronic device shown in fig. 3 is merely an example and should not be construed to limit the functionality and scope of use of the disclosed embodiments.
An electronic device includes: a memory and a processor, where the processor may be referred to as a processing device 601 hereinafter, the memory may include at least one of a Read Only Memory (ROM) 602, a Random Access Memory (RAM) 603, and a storage device 608 hereinafter, as shown in detail below:
as shown in fig. 3, the electronic device 600 may include a processing means (e.g., a central processing unit, a graphics processor, etc.) 601, which may perform various appropriate actions and processes according to a program stored in a Read Only Memory (ROM) 602 or a program loaded from a storage means 608 into a Random Access Memory (RAM) 603. In the RAM 603, various programs and data required for the operation of the electronic apparatus 600 are also stored. The processing device 601, the ROM 602, and the RAM 603 are connected to each other through a bus 604. An input/output (I/O) interface 605 is also connected to bus 604.
In general, the following devices may be connected to the I/O interface 605: input devices 606 including, for example, a touch screen, touchpad, keyboard, mouse, camera, microphone, accelerometer, gyroscope, and the like; an output device 607 including, for example, a Liquid Crystal Display (LCD), a speaker, a vibrator, and the like; storage 608 including, for example, magnetic tape, hard disk, etc.; and a communication device 609. The communication means 609 may allow the electronic device 600 to communicate with other devices wirelessly or by wire to exchange data. While fig. 3 shows an electronic device 600 having various means, it is to be understood that not all of the illustrated means are required to be implemented or provided. More or fewer devices may be implemented or provided instead.
In particular, according to embodiments of the present disclosure, the processes described above with reference to flowcharts may be implemented as computer software programs. For example, embodiments of the present disclosure include a computer program product comprising a computer program embodied on a non-transitory computer readable medium, the computer program comprising program code for performing the method shown in the flow chart. In such an embodiment, the computer program may be downloaded and installed from a network via communication means 609, or from storage means 608, or from ROM 602. The above-described functions defined in the methods of the embodiments of the present disclosure are performed when the computer program is executed by the processing device 601.
It should be noted that the computer readable medium described in the present disclosure may be a computer readable signal medium or a computer readable storage medium, or any combination of the two. The computer readable storage medium can be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or a combination of any of the foregoing. More specific examples of the computer-readable storage medium may include, but are not limited to: an electrical connection having one or more wires, a portable computer diskette, a hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing. In the context of this disclosure, a computer-readable storage medium may be any tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device. In the present disclosure, however, the computer-readable signal medium may include a data signal propagated in baseband or as part of a carrier wave, with the computer-readable program code embodied therein. Such a propagated data signal may take any of a variety of forms, including, but not limited to, electro-magnetic, optical, or any suitable combination of the foregoing. A computer readable signal medium may also be any computer readable medium that is not a computer readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device. Program code embodied on a computer readable medium may be transmitted using any appropriate medium, including but not limited to: electrical wires, fiber optic cables, RF (radio frequency), and the like, or any suitable combination of the foregoing.
In some implementations, the clients, servers may communicate using any currently known or future developed network protocol, such as HTTP (HyperText Transfer Protocol ), and may be interconnected with any form or medium of digital data communication (e.g., a communication network). Examples of communication networks include a local area network ("LAN"), a wide area network ("WAN"), the internet (e.g., the internet), and peer-to-peer networks (e.g., ad hoc peer-to-peer networks), as well as any currently known or future developed networks.
The computer readable medium may be contained in the electronic device; or may exist alone without being incorporated into the electronic device.
Computer program code for carrying out operations of the present disclosure may be written in one or more programming languages, including, but not limited to, an object oriented programming language such as Java, smalltalk, C ++ and conventional procedural programming languages, such as the "C" programming language or similar programming languages. The program code may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. In the case of a remote computer, the remote computer may be connected to the user's computer through any kind of network, including a Local Area Network (LAN) or a Wide Area Network (WAN), or may be connected to an external computer (for example, through the Internet using an Internet service provider).
The flowcharts and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present disclosure. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of code, which comprises one or more executable instructions for implementing the specified logical function(s). It should also be noted that, in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems which perform the specified functions or acts, or combinations of special purpose hardware and computer instructions.
The modules or units involved in the embodiments of the present disclosure may be implemented by means of software, or may be implemented by means of hardware. Where the name of a module or unit does not in some cases constitute a limitation of the unit itself.
The functions described above herein may be performed, at least in part, by one or more hardware logic components. For example, without limitation, exemplary types of hardware logic components that may be used include: a Field Programmable Gate Array (FPGA), an Application Specific Integrated Circuit (ASIC), an Application Specific Standard Product (ASSP), a system on a chip (SOC), a Complex Programmable Logic Device (CPLD), and the like.
In the context of this disclosure, a machine-readable medium may be a tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device. The machine-readable medium may be a machine-readable signal medium or a machine-readable storage medium. The machine-readable medium may include, but is not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any suitable combination of the foregoing. More specific examples of a machine-readable storage medium would include an electrical connection based on one or more wires, a portable computer diskette, a hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing.
According to one or more embodiments of the present disclosure, an implementation class collection management method is provided [ example A1 ], including:
marking the implementation class of the interface through a first annotation;
marking the container class of the interface through a second annotation;
at compile time, the implementation class of the interface is populated into the container class of the interface based on the first annotation and the second annotation.
A2, according to the method of claim A1, for any implementation class, the implementation class is an implementation class of a List List storage type or an implementation class of a KV storage type stored in a mapping table by adopting a key value K-V storage mode, wherein K is the identification of the implementation class, and V is an instance of the implementation class;
marking the implementation class of the interface through a first annotation, comprising:
and marking the implementation class of the interface by adopting a first annotation corresponding to the storage type of the implementation class.
A3, the method according to A2, the method further comprising:
declaring the storage space of the container class and initializing the function;
at compile time, based on the first annotation and the second annotation, populating an implementation class of the interface into a container class of the interface, comprising:
determining the corresponding relation between the implementation class and the container class based on the first annotation and the second annotation;
And at compiling, filling the implementation class into the storage space of the container class by calling the initialization function based on the corresponding relation.
A4, the method according to A3, the method further comprising:
marking the storage space of the container class through a third annotation, and marking the initializing function of the container class through a fourth annotation;
wherein the third annotation marks the data storage type of the storage space and the fourth annotation marks the initialization function for filling the implementation class of the interface into the storage space.
A5, filling the implementation class of the interface into the container class of the interface at compiling time according to the method of A3, wherein the method comprises the following steps:
if the implementation class of the interface is the implementation class of the List storage type, filling the instance of the implementation class into the storage space of the container class;
and if the implementation class of the interface is the implementation class of the KV storage type, filling K of the implementation class in the mapping table into the storage space of the container class.
A6, marking the container class of the interface through a second annotation for the implementation class of the List storage type according to the method of A5 if the construction function of the implementation class is a private function, wherein the method further comprises the steps of;
the instance of the realization class is declared to obtain the function, and the function is marked through a fifth annotation, and the fifth annotation marks the realization class of which the realization class is a single instance;
Filling an instance of the implementation class into a storage space of the container class by calling an initialization function, comprising:
and filling the instance obtaining function of the implementation class into the storage space of the container class by calling the initializing function.
A7, marking an initialization function of the container class through a fourth annotation for the implementation class of the KV storage type if the implementation class can be instantiated only once according to the method of A5, wherein the method comprises the following steps:
if the implementation class is a single-instance implementation class, marking an initialization function of the container class through a fourth annotation, and transmitting a first annotation parameter when marking, wherein the first annotation parameter marks the implementation class that the implementation class is a single-instance implementation class;
if the implementation class is a non-single implementation class, marking an initialization function of the container class through a fourth annotation, and transmitting a second annotation parameter when marking, wherein the second annotation parameter indicates that the implementation class can be instantiated only once.
A8, according to the method of A7, for the implementation class of KV storage type, if the implementation class can be instantiated only once, filling K of the implementation class in the mapping table into the storage space of the container class during compiling, including:
and when compiling, obtaining K of the implementation class in the mapping table by calling the initialization function, generating V of the implementation class, and filling the K and V of the implementation class into the storage space of the container class.
A9, the method according to A8, further comprising:
when a call request for a container class with a storage space of a List storage type is received, calling an instance of each implementation class in the storage space of the container class based on the call request;
when a call request aiming at a container class with a storage space of K-V storage type is received, searching corresponding V in the storage space of the container class based on K contained in the call request, calling the searched V if the corresponding V is found, and generating an instance of an implementation class corresponding to K and calling if the corresponding V is not found.
According to one or more embodiments of the present disclosure, there is provided a collection management apparatus of an implementation class [ example B1 ], including:
the marking module is used for marking the implementation class of the interface through the first annotation and marking the container class of the interface through the second annotation;
and the filling module is used for filling the implementation class of the interface into the container class of the interface based on the first annotation and the second annotation when compiling.
B2, according to the apparatus of claim B1, for any implementation class, the implementation class is an implementation class of a List storage type or an implementation class of a KV storage type stored in a mapping table by adopting a key value K-V storage mode, wherein K is an identification of the implementation class, and V is an instance of the implementation class;
The marking module is specifically used for marking the implementation class of the interface through a first annotation:
and marking the implementation class of the interface by adopting a first annotation corresponding to the storage type of the implementation class.
B3, the apparatus according to B2, further comprising a declaration module for:
declaring the storage space of the container class and initializing the function;
the filling module is used for filling the implementation class of the interface into the container class of the interface based on the first annotation and the second annotation during compiling, and is specifically used for:
determining the corresponding relation between the implementation class and the container class based on the first annotation and the second annotation;
and at compiling, filling the implementation class into the storage space of the container class by calling the initialization function based on the corresponding relation.
B4, the device according to B3, the marking module is also used for:
marking the storage space of the container class through a third annotation, and marking the initializing function of the container class through a fourth annotation;
wherein the third annotation marks the data storage type of the storage space and the fourth annotation marks the initialization function for filling the implementation class of the interface into the storage space.
B5, according to the device of B3, when the filling module fills the implementation class of the interface into the container class of the interface in compiling, the filling module is specifically used for:
If the implementation class of the interface is the implementation class of the List storage type, filling the instance of the implementation class into the storage space of the container class;
and if the implementation class of the interface is the implementation class of the KV storage type, filling K of the implementation class in the mapping table into the storage space of the container class.
B6, for the implementation class of the List storage type, if the construction function of the implementation class is a private function, the marking module is further used for marking the container class of the interface through the second annotation;
the instance of the realization class is declared to obtain the function, and the function is marked through a fifth annotation, and the fifth annotation marks the realization class of which the realization class is a single instance;
the filling module is specifically configured to, when the instance of the implementation class is filled into the storage space of the container class by calling the initialization function:
and filling the instance obtaining function of the implementation class into the storage space of the container class by calling the initializing function.
B7, according to the device of B5, for the implementation class of the KV storage type, if the implementation class can be instantiated only once, the marking module is specifically used for marking the initialization function of the container class through the fourth annotation:
if the implementation class is a single-instance implementation class, marking an initialization function of the container class through a fourth annotation, and transmitting a first annotation parameter when marking, wherein the first annotation parameter marks the implementation class that the implementation class is a single-instance implementation class;
If the implementation class is a non-single implementation class, marking an initialization function of the container class through a fourth annotation, and transmitting a second annotation parameter when marking, wherein the second annotation parameter indicates that the implementation class can be instantiated only once.
B8, according to the device of B7, for the implementation class of KV storage type, if the implementation class can be instantiated only once, the filling module is specifically used for filling K of the implementation class in the mapping table into the storage space of the container class when compiling:
and when compiling, obtaining K of the implementation class in the mapping table by calling the initialization function, generating V of the implementation class, and filling the K and V of the implementation class into the storage space of the container class.
B9, the device according to B8, the device further comprises a calling module for:
when a call request for a container class with a storage space of a List storage type is received, calling an instance of each implementation class in the storage space of the container class based on the call request;
when a call request aiming at a container class with a storage space of K-V storage type is received, searching corresponding V in the storage space of the container class based on K contained in the call request, calling the searched V if the corresponding V is found, and generating an instance of an implementation class corresponding to K and calling if the corresponding V is not found.
According to one or more embodiments of the present disclosure, there is provided an electronic device [ example C1 ], comprising:
a processor and a memory;
a memory for storing computer operating instructions;
a processor for executing the method of any one of A1 to A9 by invoking computer operation instructions.
According to one or more embodiments of the present disclosure, a computer-readable medium is provided [ example D1 ], the readable medium storing at least one instruction, at least one program, code set, or instruction set, the at least one instruction, at least one program, code set, or instruction set being loaded and executed by a processor to implement the method of any one of A1 to A9.
The foregoing description is only of the preferred embodiments of the present disclosure and description of the principles of the technology being employed. It will be appreciated by persons skilled in the art that the scope of the disclosure referred to in this disclosure is not limited to the specific combinations of features described above, but also covers other embodiments which may be formed by any combination of features described above or equivalents thereof without departing from the spirit of the disclosure. Such as those described above, are mutually substituted with the technical features having similar functions disclosed in the present disclosure (but not limited thereto).
Moreover, although operations are depicted in a particular order, this should not be understood as requiring that such operations be performed in the particular order shown or in sequential order. In certain circumstances, multitasking and parallel processing may be advantageous. Likewise, while several specific implementation details are included in the above discussion, these should not be construed as limiting the scope of the present disclosure. Certain features that are described in the context of separate embodiments can also be implemented in combination in a single embodiment. Conversely, various features that are described in the context of a single embodiment can also be implemented in multiple embodiments separately or in any suitable subcombination.
Although the subject matter has been described in language specific to structural features and/or methodological acts, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or acts described above. Rather, the specific features and acts described above are example forms of implementing the claims.
Claims (12)
1. A method for implementing collection management of classes, comprising:
marking the implementation class of the interface through a first annotation;
Marking the container class of the interface through a second annotation;
and at compiling, determining the corresponding relation between the implementation class and the container class based on the first annotation and the second annotation, and filling the implementation class of the interface into the container class of the interface based on the corresponding relation.
2. The method according to claim 1, wherein the implementation class is a List storage type implementation class or a KV storage type implementation class stored in a mapping table by adopting a key value K-V storage manner, where K is an identification of the implementation class and V is an instance of the implementation class;
the marking the implementation class of the interface through the first annotation comprises the following steps:
and marking the implementation class of the interface by adopting a first annotation corresponding to the storage type of the implementation class.
3. The method according to claim 2, wherein the method further comprises:
declaring a memory space and an initialization function of the container class;
the compiling, based on the first annotation and the second annotation, determines a corresponding relation between the implementation class and the container class, and fills the implementation class of the interface into the container class of the interface based on the corresponding relation, including:
And filling the implementation class into the storage space of the container class by calling the initialization function based on the corresponding relation during compiling.
4. A method according to claim 3, characterized in that the method further comprises:
marking the storage space of the container class through a third annotation, and marking the initializing function of the container class through a fourth annotation;
the third annotation marks the data storage type of the storage space, and the fourth annotation marks the initialization function to be used for filling the implementation class of the interface into the storage space.
5. A method according to claim 3, wherein filling the implementation class of the interface into the container class of the interface at compile time comprises:
if the implementation class of the interface is the implementation class of the List storage type, filling the instance of the implementation class into the storage space of the container class;
and if the implementation class of the interface is the implementation class of the KV storage type, filling K of the implementation class in the mapping table into the storage space of the container class.
6. The method of claim 5, wherein for an implementation class of a List store type, if the constructor of the implementation class is a private function, the method further comprises, when marking the container class of the interface by the second annotation;
The instance obtaining function of the implementation class is declared and marked through a fifth annotation, wherein the fifth annotation marks the implementation class that the implementation class is a single instance;
the filling the instance of the implementation class into the storage space of the container class by calling the initialization function comprises the following steps:
and filling the instance obtaining function of the implementation class into the storage space of the container class by calling the initializing function.
7. The method of claim 4, wherein for an implementation class of KV storage type, the marking the initialization function of the container class with the fourth annotation if the implementation class can only be instantiated once comprises:
if the implementation class is a single-instance implementation class, marking an initialization function of the container class through a fourth annotation, and transmitting a first annotation parameter when marking, wherein the first annotation parameter marks the implementation class that the implementation class is a single-instance implementation class;
if the implementation class is a non-single implementation class, marking the initialization function of the container class through a fourth annotation, and transmitting a second annotation parameter when marking, wherein the second annotation parameter indicates that the implementation class can be instantiated only once.
8. The method of claim 7, wherein for an implementation class of KV storage type, if the implementation class can only be instantiated once, the filling K of the implementation class in the mapping table into the storage space of the container class at compile time comprises:
and when compiling, obtaining K of the implementation class in the mapping table by calling the initialization function, generating V of the implementation class, and filling the K and V of the implementation class into the storage space of the container class.
9. The method of claim 8, wherein the method further comprises:
when a call request for a container class with a storage space of a List storage type is received, calling an instance of each implementation class in the storage space of the container class based on the call request;
when a call request aiming at a container class with a K-V storage type storage space is received, searching corresponding V in the storage space of the container class based on K contained in the call request, calling the searched V if the corresponding V is found, and generating an instance of an implementation class corresponding to the K and calling if the corresponding V is not found.
10. An implementation class collection management device, comprising:
The marking module is used for marking the implementation class of the interface through a first annotation and marking the container class of the interface through a second annotation;
and the filling module is used for determining the corresponding relation between the implementation class and the container class based on the first annotation and the second annotation when compiling, and filling the implementation class of the interface into the container class of the interface based on the corresponding relation.
11. An electronic device, comprising:
a processor and a memory;
the memory is used for storing computer operation instructions;
the processor is configured to perform the method of any one of claims 1 to 9 by invoking the computer operating instructions.
12. A computer readable medium having stored thereon at least one instruction, at least one program, code set or instruction set, the at least one instruction, the at least one program, code set or instruction set being loaded and executed by a processor to implement the method of any of claims 1 to 9.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010219123.XA CN113448550B (en) | 2020-03-25 | 2020-03-25 | Method and device for realizing collection management of classes, electronic equipment and computer medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010219123.XA CN113448550B (en) | 2020-03-25 | 2020-03-25 | Method and device for realizing collection management of classes, electronic equipment and computer medium |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN113448550A CN113448550A (en) | 2021-09-28 |
| CN113448550B true CN113448550B (en) | 2023-12-15 |
Family
ID=77806850
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202010219123.XA Active CN113448550B (en) | 2020-03-25 | 2020-03-25 | Method and device for realizing collection management of classes, electronic equipment and computer medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN113448550B (en) |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN107835178A (en) * | 2017-11-13 | 2018-03-23 | 北京奇艺世纪科技有限公司 | A kind of multi-protocols communication for service method, apparatus and electronic equipment |
| CN109375901A (en) * | 2018-09-03 | 2019-02-22 | 平安普惠企业管理有限公司 | Interface message management method, device, computer equipment and storage medium |
| CN109710428A (en) * | 2018-12-27 | 2019-05-03 | 杭州数梦工场科技有限公司 | A kind of dynamic call method and device for realizing class |
Family Cites Families (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US8032860B2 (en) * | 2003-02-26 | 2011-10-04 | Oracle International Corporation | Methods for type-independent source code editing |
| JP2015184824A (en) * | 2014-03-20 | 2015-10-22 | 富士通株式会社 | Information processing program, information processing method, and information processing apparatus |
| WO2017056194A1 (en) * | 2015-09-29 | 2017-04-06 | 株式会社 東芝 | Information device, information communication terminal, and information processing method |
-
2020
- 2020-03-25 CN CN202010219123.XA patent/CN113448550B/en active Active
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN107835178A (en) * | 2017-11-13 | 2018-03-23 | 北京奇艺世纪科技有限公司 | A kind of multi-protocols communication for service method, apparatus and electronic equipment |
| CN109375901A (en) * | 2018-09-03 | 2019-02-22 | 平安普惠企业管理有限公司 | Interface message management method, device, computer equipment and storage medium |
| CN109710428A (en) * | 2018-12-27 | 2019-05-03 | 杭州数梦工场科技有限公司 | A kind of dynamic call method and device for realizing class |
Also Published As
| Publication number | Publication date |
|---|---|
| CN113448550A (en) | 2021-09-28 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN110489101B (en) | Interface simulation method, system, medium and electronic equipment | |
| CN112214408B (en) | Dependency conflict detection method, dependency conflict detection device, electronic equipment and computer readable medium | |
| CN111309304B (en) | Method, device, medium and electronic equipment for generating IDL file | |
| CN111796865B (en) | Byte code file modification method, device, terminal equipment and medium | |
| CN110865852B (en) | Webpage component loading method and device, electronic equipment and storage medium | |
| CN113391860B (en) | Service request processing method and device, electronic equipment and computer storage medium | |
| CN114625536A (en) | Video memory allocation method, device, medium and electronic equipment | |
| CN111273830A (en) | Data display method and device, electronic equipment and computer readable medium | |
| CN112416303B (en) | Software development kit hot repair method and device and electronic equipment | |
| CN111400068B (en) | Interface control method and device, readable medium and electronic equipment | |
| CN111597107B (en) | Information output method and device and electronic equipment | |
| CN111414152B (en) | Method, system, readable medium and electronic device for realizing business logic | |
| CN111324258B (en) | Method, device, equipment and medium for generating contents of configuration items of multilevel pull-down menu | |
| WO2024212839A1 (en) | Card layout method and apparatus, medium and electronic device | |
| CN109669720B (en) | Chain type asynchronous request processing method and device based on Promise and electronic equipment | |
| CN113448550B (en) | Method and device for realizing collection management of classes, electronic equipment and computer medium | |
| CN112379967B (en) | Simulator detection method, device, equipment and medium | |
| CN113296771B (en) | Page display method, device, equipment and computer readable medium | |
| CN113204557B (en) | Electronic form importing method, device, equipment and medium | |
| CN111258786B (en) | Decoupling method, device, terminal and storage medium in layered architecture | |
| CN111399902B (en) | Client source file processing method and device, readable medium and electronic equipment | |
| CN111625326B (en) | Task pipeline execution method and device and electronic equipment | |
| CN111241368B (en) | Data processing method, device, medium and equipment | |
| CN116263824A (en) | Resource access method and device, storage medium and electronic equipment | |
| CN114047922B (en) | Transcoding method, device, medium and equipment for precompiled device |
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 | ||
| CB02 | Change of applicant information |
Address after: 100041 B-0035, 2 floor, 3 building, 30 Shixing street, Shijingshan District, Beijing. Applicant after: Tiktok vision (Beijing) Co.,Ltd. Address before: 100041 B-0035, 2 floor, 3 building, 30 Shixing street, Shijingshan District, Beijing. Applicant before: BEIJING BYTEDANCE NETWORK TECHNOLOGY Co.,Ltd. Address after: 100041 B-0035, 2 floor, 3 building, 30 Shixing street, Shijingshan District, Beijing. Applicant after: Douyin Vision Co.,Ltd. Address before: 100041 B-0035, 2 floor, 3 building, 30 Shixing street, Shijingshan District, Beijing. Applicant before: Tiktok vision (Beijing) Co.,Ltd. |
|
| CB02 | Change of applicant information | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |