CN111427581A - Method, device, equipment and medium for realizing type multi-inheritance - Google Patents
Method, device, equipment and medium for realizing type multi-inheritance Download PDFInfo
- Publication number
- CN111427581A CN111427581A CN202010221672.0A CN202010221672A CN111427581A CN 111427581 A CN111427581 A CN 111427581A CN 202010221672 A CN202010221672 A CN 202010221672A CN 111427581 A CN111427581 A CN 111427581A
- Authority
- CN
- China
- Prior art keywords
- class
- merged
- interface
- super
- inheritance
- 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.)
- Granted
Links
- 238000000034 method Methods 0.000 title claims abstract description 84
- 238000000605 extraction Methods 0.000 claims abstract description 12
- 238000004590 computer program Methods 0.000 claims description 13
- 230000004044 response Effects 0.000 claims description 4
- 238000012546 transfer Methods 0.000 claims description 3
- 230000006870 function Effects 0.000 description 15
- 238000010586 diagram Methods 0.000 description 14
- 238000013461 design Methods 0.000 description 3
- 230000001360 synchronised effect Effects 0.000 description 3
- 230000000694 effects Effects 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 230000003287 optical effect Effects 0.000 description 2
- 230000008569 process Effects 0.000 description 2
- 238000013068 supply chain management Methods 0.000 description 2
- 230000009286 beneficial effect Effects 0.000 description 1
- 238000004891 communication Methods 0.000 description 1
- 238000005516 engineering process Methods 0.000 description 1
- 230000014509 gene expression Effects 0.000 description 1
- 238000007726 management method Methods 0.000 description 1
- 238000006467 substitution reaction Methods 0.000 description 1
- 230000009466 transformation Effects 0.000 description 1
- 238000000844 transformation Methods 0.000 description 1
Images
Classifications
-
- 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
Abstract
The invention discloses a method for realizing type multi-inheritance, which comprises the following steps: extracting an interface from a method and an attribute which need to be inherited by each superclass in a plurality of superclasses to be inherited; recording the superclass and an interface corresponding to the superclass; combining a plurality of superclasses into a combined class through dynamic compiling, and configuring the combined class as an interface for realizing extraction of all the combined superclasses; and responding to the realization of the interface method, combining the super classes and transferring the combined super classes to the corresponding methods respectively. The invention also discloses a device, equipment and a medium. The method, the device, the equipment and the medium for realizing type multi-inheritance provided by the invention can realize class inheritance of a plurality of super classes.
Description
Technical Field
The present invention relates to the field of computer technologies, and in particular, to a method, an apparatus, a device, and a medium for implementing type multi-inheritance.
Background
The mainstream programming languages used by modern software systems hardly support one class to inherit multiple parent classes, and only support interfaces to inherit multiple interfaces.
Disclosure of Invention
In view of this, an object of the embodiments of the present invention is to provide a method for implementing type multi-inheritance, so that each method of a class can be developed and deployed respectively.
Based on the above object, an aspect of the present invention provides a method for implementing type multiple inheritance, including:
extracting an interface from a method and an attribute which need to be inherited by each superclass in a plurality of superclasses to be inherited;
recording the superclass and an interface corresponding to the superclass;
combining a plurality of superclasses into a combined class through dynamic compiling, and configuring the combined class as an interface for realizing extraction of all the combined superclasses;
and responding to the realization of the interface method, combining the super classes and transferring the combined super classes to the corresponding methods respectively.
In some embodiments of the method for implementing type multi-inheritance of the present invention, recording the superclass and the interface corresponding to the superclass further comprises:
and recording the super class and the interface corresponding to the super class through the configuration file.
In some embodiments of the method for implementing type multi-inheritance according to the present invention, the step of merging a plurality of super classes into a merged class through dynamic compilation, and configuring the merged class as an interface for implementing extraction of all the merged super classes further includes:
and finding interfaces of the merged class and the merged super class through the configuration file.
In some embodiments of the method for implementing type multi-inheritance according to the present invention, the step of merging a plurality of super classes into a merged class through dynamic compilation, and configuring the merged class as an interface for implementing extraction of all the merged super classes further includes:
dynamic compilation is achieved by microsoft, csharp, csharpcodeprovider or Roslyn in DotNet or javaccompiler in Java.
In another aspect of the embodiments of the present invention, a device for implementing type multiple inheritance is further provided, where the device includes:
the interface extraction module is configured to extract an interface from the method and the attribute which need to be inherited by each of a plurality of super classes to be inherited;
the recording module is configured to record the super class and an interface corresponding to the super class;
the merging module is configured to merge the plurality of super classes into a merged class through dynamic compiling, and configure the merged class as an interface for realizing extraction of all the merged super classes;
and the method transferring module is configured to combine the methods corresponding to the superclasss combined by class transferring in response to the realization of the interface method.
In some embodiments of the apparatus implementing type multiple inheritance of the present invention, the recording module is further configured to:
and recording the super class and the interface corresponding to the super class through the configuration file.
In some embodiments of the apparatus implementing type multiple inheritance of the present invention, the merging module is further configured to:
and finding interfaces of the merged class and the merged super class through the configuration file.
In some embodiments of the apparatus implementing type multiple inheritance of the present invention, the merging module is further configured to:
dynamic compilation is achieved by microsoft, csharp, csharpcodeprovider or Roslyn in DotNet or javaccompiler in Java.
In another aspect of the embodiments of the present invention, there is also provided a computer device, including:
at least one processor; and
a memory storing a computer program operable on a processor, the processor executing the program to perform the method of implementing multi-inheritance of a type as previously described.
In another aspect of the embodiments of the present invention, a computer-readable storage medium is further provided, where a computer program is stored, and is characterized in that when being executed by a processor, the computer program performs the foregoing method for implementing type multi-inheritance.
The invention has at least the following beneficial technical effects: by defining a set of flow and method, the problem that the type in a software system written by a modern high-level programming language cannot simultaneously inherit the methods and attributes on a plurality of superclasses is solved.
Drawings
In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings used in the description of the embodiments or the prior art will be briefly described below, and it is obvious that the drawings in the following description are only some embodiments of the present invention, and it is obvious for those skilled in the art that other embodiments can be obtained by using the drawings without creative efforts.
FIG. 1 shows a schematic block diagram of an embodiment of a method of implementing type multi-inheritance in accordance with the present invention;
FIG. 2 is a structural diagram illustrating a class diagram after an abstraction interface according to an embodiment of the method of implementing type multi-inheritance of the present invention;
FIG. 3 is a structural diagram illustrating the dynamic compilation of an embodiment of a method for implementing type multi-inheritance according to the present invention to generate merged classes;
FIG. 4 shows a timing diagram of a method transfer according to an embodiment of the present invention implementing a type multiple inheritance method.
Detailed Description
In order to make the objects, technical solutions and advantages of the present invention more apparent, the following embodiments of the present invention are described in further detail with reference to the accompanying drawings.
It should be noted that all expressions using "first" and "second" in the embodiments of the present invention are used for distinguishing two entities with the same name but different names or different parameters, and it is understood that "first" and "second" are only used for convenience of description and should not be construed as limiting the embodiments of the present invention, and the descriptions thereof in the following embodiments are omitted.
In view of the foregoing, a first aspect of the embodiments of the present invention provides an embodiment of a method for implementing type multi-inheritance. FIG. 1 is a schematic diagram illustrating an embodiment of a method for implementing type multi-inheritance according to the present invention. In the embodiment shown in fig. 1, the method comprises at least the following steps:
s100, extracting an interface from a method and an attribute which need to be inherited by each of a plurality of super classes to be inherited;
s200, recording the superclass and an interface corresponding to the superclass;
s300, combining the plurality of super classes into a combined class through dynamic compiling, and configuring the combined class as an interface for realizing extraction of all the combined super classes;
s400, responding to the realization of the interface method, combining the super classes and transferring the combined super classes to the corresponding methods.
In some embodiments of the present invention, the method and the attribute that need to be inherited in the super class to be inherited are extracted out of the interface, and the super class and the corresponding interface are recorded. In some embodiments, there are three super classes to be inherited, which are ClassA, ClassB, and ClassC, respectively, and fig. 2 is a schematic structural diagram illustrating a post-extraction-interface class diagram according to an embodiment of the method for implementing type multi-inheritance of the present invention, where the post-extraction-interface class diagram is shown in fig. 2.
After the software system is run, a class is generated by utilizing the dynamic compiling capability, simultaneously, interfaces extracted from all the merged classes are realized, and a corresponding method in the corresponding merged class modulation class is established in the realization of an interface method.
According to some embodiments of the method for implementing type multi-inheritance of the present invention, recording the superclass and the interface corresponding to the superclass further comprises:
and recording the super class and the interface corresponding to the super class through the configuration file.
In some embodiments of the invention, classes and corresponding interfaces are recorded via a configuration file or other means.
According to some embodiments of the method for implementing type multi-inheritance of the present invention, the step of merging the plurality of super classes into a merged class through dynamic compilation, and the step of configuring the merged class as an interface for implementing extraction of all the merged super classes further comprises:
and finding interfaces of the merged class and the merged super class through the configuration file.
In some embodiments of the present invention, during service runtime, dynamic compilation is used to find classes to be merged and class interfaces according to a configuration file or other manners, and the interfaces of the classes to be merged are combined to generate a new class, i.e., a merged class.
According to some embodiments of the method for implementing type multi-inheritance of the present invention, the step of merging the plurality of super classes into a merged class through dynamic compilation, and the step of configuring the merged class as an interface for implementing extraction of all the merged super classes further comprises:
dynamic compilation is achieved by microsoft, csharp, csharpcodeprovider or Roslyn in DotNet or javaccompiler in Java.
In some embodiments of the invention, a class is generated after the software system is run using dynamic (with respect to the software development phase) compilation capabilities (e.g., Microsoft, CSharp, CSharpCodProvider in DotNet or Roslyn and JavaCompiler in Java).
In another embodiment of the present invention, taking the sales order management function of the supply chain management system as an example, a sales order service named salesredervice is developed, which provides functions of adding sales orders (Add), viewing sales orders (Retrieve), and the like. The sales order business is divided into warehousing and ex-warehousing, a warehousing service (named as sogoodsrechervice) has all functions of sales order service, and a warehousing method (goodsrechervice) is added at the same time, and an ex-warehousing service (named as sogoodscuseservice) has all functions of sales order service and an ex-warehousing method (goodscusue) is added at the same time.
When the supply chain management system is applied to military enterprises, customers generally require:
the sales order service provides a function of setting a privacy level;
the warehousing service provides a function of setting security and merging into the warehouse;
the ex-warehouse service provides the functions of setting confidentiality and ex-warehouse;
according to the requirements, related developers develop military industry sales order service on the basis of sales order service, wherein the military industry sales order service is named as MilitarySOService and provides a function of setting a security level (SetSecure L evel), develop military industry warehousing service on the basis of the military industry sales order service and warehousing service, is named as MilitarySOGoodsReceiveService and provides a function of setting security and warehousing (SetSecure L evenAndGoodsReceive), and develop military industry ex-warehouse service on the basis of the military industry sales order service and ex-warehouse service, is named as MilitarySOGoodsIssueService and provides a function of setting security and ex-warehouse (SetSecurie L evenAndGoodsIssue).
In service operation, dynamic compilation is utilized, classes to be merged and class interfaces are found according to configuration files or other modes, the interfaces of the classes to be merged are combined to generate a new class of Military SOGoodsReceiveServiceImpl and Military SOGoodsIssuerviceImpl, FIG. 3 is a structural schematic diagram of generating the merged classes by dynamic compilation according to an embodiment of the method for realizing type multi-inheritance of the present invention, and the class diagram is shown in FIG. 3.
When the service consumer needs to use the warehousing service, the generated instance of the militarysogoodsrechaceserviceimpl class is returned, and when the ex-warehousing service needs to be used, the generated instance of the MilitarySOGoodsIssueServiceImpl class is returned. Because the millitariysoodsrecherviceimpl and the millitariysoodsisoserviceimpl are classes generated by dynamic compilation, and cannot be directly used by service consumers, a factory design pattern or the like is generally required to create instances.
When a service consumer calls a method on a service, a corresponding method on an implementation class where an intra-class callback method is implemented is taken as an example of millitariysoodsrechaceserviceimpl, and fig. 4 shows a sequence diagram of method callbacks according to an embodiment of the method for implementing multi-inheritance of types of implementation of the present invention, and the call sequence diagram is shown in fig. 4.
For the above-mentioned class creation interface, the interface name is uniformly specified as the beginning of the class name with the added letter I (for example, the interface name created by salesrerservice is isaleserdrervice), and the class diagram after the interface is created is as follows:
in another aspect of the embodiments of the present invention, an embodiment of a device for implementing type multiple inheritance is provided. The device includes:
the interface extraction module is configured to extract an interface from the method and the attribute which need to be inherited by each of a plurality of super classes to be inherited;
the recording module is configured to record the super class and an interface corresponding to the super class;
the merging module is configured to merge the plurality of super classes into a merged class through dynamic compiling, and configure the merged class as an interface for realizing extraction of all the merged super classes;
and the method transferring module is configured to combine the methods corresponding to the superclasss combined by class transferring in response to the realization of the interface method.
According to some embodiments of the apparatus implementing type multiple inheritance of the present invention, the recording module is further configured to:
and recording the super class and the interface corresponding to the super class through the configuration file.
According to some embodiments of the apparatus implementing type multiple inheritance of the present invention, the merging module is further configured to:
and finding interfaces of the merged class and the merged super class through the configuration file.
According to some embodiments of the apparatus implementing type multiple inheritance of the present invention, the merging module is further configured to:
dynamic compilation is achieved by microsoft, csharp, csharpcodeprovider or Roslyn in DotNet or javaccompiler in Java.
In view of the above object, another aspect of the embodiments of the present invention further provides a computer device, including: at least one processor; and a memory storing a computer program operable on the processor, the processor executing the program to perform the method of implementing multi-inheritance of types as previously described.
In another aspect of the embodiments of the present invention, a computer-readable storage medium is further provided, where a computer program is stored, and is characterized in that when being executed by a processor, the computer program performs the foregoing method for implementing type multi-inheritance.
Likewise, it will be appreciated by those skilled in the art that all of the embodiments, features and advantages set forth above with respect to the method of implementing type multiple inheritance according to the present invention apply equally well to the apparatus, the computer device and the medium according to the present invention. For the sake of brevity of the present disclosure, no repeated explanation is provided herein.
It should be particularly noted that, the steps in the embodiments of the method, apparatus, device and medium for implementing type multiple inheritance as described above can be mutually intersected, replaced, added and deleted, so that these reasonable permutation and combination transformations also belong to the scope of the present invention for implementing type multiple inheritance, and should not limit the scope of the present invention to the embodiments.
Finally, it should be noted that, as those skilled in the art can understand that all or part of the processes in the methods of the above embodiments can be implemented by instructing relevant hardware through a computer program, and a program for implementing the method of type multiple inheritance may be stored in a computer readable storage medium, and when executed, the program may include the processes of the embodiments of the methods as described above. The storage medium of the program may be a magnetic disk, an optical disk, a Read Only Memory (ROM), a Random Access Memory (RAM), or the like. The embodiments of the computer program may achieve the same or similar effects as any of the above-described method embodiments.
Furthermore, the methods disclosed according to embodiments of the present invention may also be implemented as a computer program executed by a processor, which may be stored in a computer-readable storage medium. Which when executed by a processor performs the above-described functions defined in the methods disclosed in embodiments of the invention.
Further, the above method steps and system elements may also be implemented using a controller and a computer readable storage medium for storing a computer program for causing the controller to implement the functions of the above steps or elements.
Further, it should be understood that the computer-readable storage media (e.g., memory) herein may be either volatile memory or nonvolatile memory, or may include both volatile and nonvolatile memory, by way of example and not limitation, nonvolatile memory may include Read Only Memory (ROM), Programmable ROM (PROM), Electrically Programmable ROM (EPROM), Electrically Erasable Programmable ROM (EEPROM), or flash memory volatile memory may include Random Access Memory (RAM), which may serve as external cache memory, by way of example and not limitation, RAM may be available in a variety of forms, such as synchronous RAM (DRAM), Dynamic RAM (DRAM), Synchronous DRAM (SDRAM), Double Data Rate SDRAM (DDRSDRAM), Enhanced SDRAM (ESDRAM), synchronous link DRAM (S L DRAM, and Direct Rambus RAM (DRRAM).
Those of skill would further appreciate that the various illustrative logical blocks, modules, circuits, and algorithm steps described in connection with the disclosure herein may be implemented as electronic hardware, computer software, or combinations of both. To clearly illustrate this interchangeability of hardware and software, various illustrative components, blocks, modules, circuits, and steps have been described above generally in terms of their functionality. Whether such functionality is implemented as software or hardware depends upon the particular application and design constraints imposed on the overall system. Skilled artisans may implement the described functionality in varying ways for each particular application, but such implementation decisions should not be interpreted as causing a departure from the scope of the disclosed embodiments of the present invention.
The various illustrative logical blocks, modules, and circuits described in connection with the disclosure herein may be implemented or performed with the following components designed to perform the functions herein: a general purpose processor, a Digital Signal Processor (DSP), an Application Specific Integrated Circuit (ASIC), a Field Programmable Gate Array (FPGA) or other programmable logic device, discrete gate or transistor logic, discrete hardware components, or any combination of these components. A general purpose processor may be a microprocessor, but in the alternative, the processor may be any conventional processor, controller, microcontroller, or state machine. A processor may also be implemented as a combination of computing devices, e.g., a combination of a DSP and a microprocessor, a plurality of microprocessors, one or more microprocessors in conjunction with a DSP, and/or any other such configuration.
The steps of a method or algorithm described in connection with the disclosure herein may be embodied directly in hardware, in a software module executed by a processor, or in a combination of the two. A software module may reside in RAM memory, flash memory, ROM memory, EPROM memory, EEPROM memory, registers, hard disk, a removable disk, a CD-ROM, or any other form of storage medium known in the art. An exemplary storage medium is coupled to the processor such the processor can read information from, and write information to, the storage medium. In the alternative, the storage medium may be integral to the processor. The processor and the storage medium may reside in an ASIC. The ASIC may reside in a user terminal. In the alternative, the processor and the storage medium may reside as discrete components in a user terminal.
In one or more exemplary designs, the functions may be implemented in hardware, software, firmware, or any combination thereof.A computer readable medium includes a computer storage medium and a communication medium including any medium that facilitates transfer of a computer program from one location to another.A storage medium may be any available medium that can be accessed by a general purpose or special purpose computer.
The foregoing is an exemplary embodiment of the present disclosure, but it should be noted that various changes and modifications could be made herein without departing from the scope of the present disclosure as defined by the appended claims. The functions, steps and/or actions of the method claims in accordance with the disclosed embodiments described herein need not be performed in any particular order. Furthermore, although elements of the disclosed embodiments of the invention may be described or claimed in the singular, the plural is contemplated unless limitation to the singular is explicitly stated.
It should be understood that, as used herein, the singular forms "a", "an" and "the" are intended to include the plural forms as well, unless the context clearly supports the exception. It should also be understood that "and/or" as used herein is meant to include any and all possible combinations of one or more of the associated listed items.
The numbers of the embodiments disclosed in the embodiments of the present invention are merely for description, and do not represent the merits of the embodiments.
It will be understood by those skilled in the art that all or part of the steps for implementing the above embodiments may be implemented by hardware, or may be implemented by a program instructing relevant hardware, and the program may be stored in a computer-readable storage medium, and the above-mentioned storage medium may be a read-only memory, a magnetic disk or an optical disk, etc.
Those of ordinary skill in the art will understand that: the discussion of any embodiment above is meant to be exemplary only, and is not intended to intimate that the scope of the disclosure, including the claims, of embodiments of the invention is limited to these examples; within the idea of an embodiment of the invention, also technical features in the above embodiment or in different embodiments may be combined and there are many other variations of the different aspects of the embodiments of the invention as described above, which are not provided in detail for the sake of brevity. Therefore, any omissions, modifications, substitutions, improvements, and the like that may be made without departing from the spirit and principles of the embodiments of the present invention are intended to be included within the scope of the embodiments of the present invention.
Claims (10)
1. A method for implementing type multi-inheritance, the method comprising:
extracting an interface from a method and an attribute which need to be inherited by each of a plurality of superclasses to be inherited;
recording the super class and the interface corresponding to the super class;
combining a plurality of the superclasses into a combined class through dynamic compiling, and configuring the combined class as the interface extracted by all the combined superclasses;
in response to implementing an interface method, the merge class transfers the methods to which the merged superclass respectively corresponds.
2. The method of claim 1, wherein said recording the superclass and the interface corresponding to the superclass further comprises:
and recording the super class and the interface corresponding to the super class through a configuration file.
3. The method for implementing type multi-inheritance according to claim 1, wherein the interface for merging a plurality of said super-classes into a merged class through dynamic compilation and configuring the merged class to be extracted from all the merged super-classes further comprises:
finding the interfaces of the merged class and the merged super class from a configuration file.
4. The method for implementing type multi-inheritance according to claim 1, wherein the interface for merging a plurality of said super-classes into a merged class through dynamic compilation and configuring the merged class to be extracted from all the merged super-classes further comprises:
the dynamic compilation is achieved by microsoft, csharp, csharpcodeprovider or Roslyn in DotNet or javactiler in Java.
5. An apparatus that implements type multi-inheritance, the apparatus comprising:
the interface extraction module is configured to extract an interface from the method and the attribute which need to be inherited by each of a plurality of superclasses to be inherited;
a recording module configured to record the super class and the interface corresponding to the super class;
a merging module configured to merge the plurality of superclasses into a merged class by dynamic compilation, and configure the merged class as the interface extracted from all the merged superclasses;
a method tuning module configured to tune the merged superclass to the respective corresponding methods in response to implementing an interface method.
6. The apparatus for implementing type multi-inheritance of claim 6, wherein the recording module is further configured to:
and recording the super class and the interface corresponding to the super class through a configuration file.
7. The apparatus for implementing type multi-inheritance of claim 6, wherein the merging module is further configured to:
finding the interfaces of the merged class and the merged super class from a configuration file.
8. The apparatus for implementing type multi-inheritance of claim 6, wherein the merging module is further configured to:
the dynamic compilation is implemented by microsoft, csharp, csharpcodeprovider or Roslyn in DotNet or javactiler in Java.
9. A computer device, comprising:
at least one processor; and
memory storing a computer program operable on the processor, wherein the processor, when executing the program, performs the method of any of claims 1-5.
10. A computer-readable storage medium, in which a computer program is stored which, when being executed by a processor, is adapted to carry out the method of any one of claims 1 to 5.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010221672.0A CN111427581B (en) | 2020-03-26 | 2020-03-26 | Method, device, equipment and medium for realizing type multi-inheritance |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010221672.0A CN111427581B (en) | 2020-03-26 | 2020-03-26 | Method, device, equipment and medium for realizing type multi-inheritance |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN111427581A true CN111427581A (en) | 2020-07-17 |
| CN111427581B CN111427581B (en) | 2023-02-21 |
Family
ID=71548793
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202010221672.0A Active CN111427581B (en) | 2020-03-26 | 2020-03-26 | Method, device, equipment and medium for realizing type multi-inheritance |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN111427581B (en) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN111930363A (en) * | 2020-08-07 | 2020-11-13 | 北京字节跳动网络技术有限公司 | Block interface code generation method and device |
Citations (8)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US5313630A (en) * | 1990-04-25 | 1994-05-17 | Hitachi, Ltd. | System of object oriented inheritance using the temporal status of superclasses |
| CN106201514A (en) * | 2016-07-11 | 2016-12-07 | 电子科技大学 | The structure of a kind of WebGIS Development Framework based on OpenLayers and using method |
| CN108196916A (en) * | 2017-12-18 | 2018-06-22 | 广州视源电子科技股份有限公司 | A kind of method and its device, storage medium and electronic equipment that parameter verification is carried out to interface |
| US20180349150A1 (en) * | 2017-06-05 | 2018-12-06 | International Business Machines Corporation | Facilitating multi-inheritance within a single inheritance container-based environment |
| CN109960503A (en) * | 2017-12-26 | 2019-07-02 | 北京金风科创风电设备有限公司 | Component development method and device based on Django framework |
| CN110232088A (en) * | 2019-06-13 | 2019-09-13 | 华中师范大学 | The combined method and device of classification, storage medium |
| CN110515676A (en) * | 2019-07-11 | 2019-11-29 | 平安普惠企业管理有限公司 | Interface integration method, device, equipment and storage medium |
| CN110704035A (en) * | 2019-10-17 | 2020-01-17 | 北京首贝科技发展有限公司 | Plug-in type software architecture system and implementation method thereof |
-
2020
- 2020-03-26 CN CN202010221672.0A patent/CN111427581B/en active Active
Patent Citations (8)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US5313630A (en) * | 1990-04-25 | 1994-05-17 | Hitachi, Ltd. | System of object oriented inheritance using the temporal status of superclasses |
| CN106201514A (en) * | 2016-07-11 | 2016-12-07 | 电子科技大学 | The structure of a kind of WebGIS Development Framework based on OpenLayers and using method |
| US20180349150A1 (en) * | 2017-06-05 | 2018-12-06 | International Business Machines Corporation | Facilitating multi-inheritance within a single inheritance container-based environment |
| CN108196916A (en) * | 2017-12-18 | 2018-06-22 | 广州视源电子科技股份有限公司 | A kind of method and its device, storage medium and electronic equipment that parameter verification is carried out to interface |
| CN109960503A (en) * | 2017-12-26 | 2019-07-02 | 北京金风科创风电设备有限公司 | Component development method and device based on Django framework |
| CN110232088A (en) * | 2019-06-13 | 2019-09-13 | 华中师范大学 | The combined method and device of classification, storage medium |
| CN110515676A (en) * | 2019-07-11 | 2019-11-29 | 平安普惠企业管理有限公司 | Interface integration method, device, equipment and storage medium |
| CN110704035A (en) * | 2019-10-17 | 2020-01-17 | 北京首贝科技发展有限公司 | Plug-in type software architecture system and implementation method thereof |
Non-Patent Citations (1)
| Title |
|---|
| ALS RITTER: "Java代理模式", 《HTTPS://ALSRITTER.ICU/POSTS/CFFAADF/》 * |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN111930363A (en) * | 2020-08-07 | 2020-11-13 | 北京字节跳动网络技术有限公司 | Block interface code generation method and device |
| CN111930363B (en) * | 2020-08-07 | 2023-11-24 | 抖音视界有限公司 | Block interface code generation method and device |
Also Published As
| Publication number | Publication date |
|---|---|
| CN111427581B (en) | 2023-02-21 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| RU2725690C1 (en) | Service processing method and device | |
| CN110032599B (en) | Data structure reading and updating method and device, and electronic equipment | |
| US7607126B2 (en) | System and method for external override of annotations | |
| CN109299587A (en) | Algorithm protection method, device, equipment and storage medium based on go language | |
| US8141035B2 (en) | Method for accessing internal states of objects in object oriented programming | |
| US9304762B2 (en) | Automatically customizing a computer-executable application at runtime | |
| CN110032568B (en) | Data structure reading and updating method and device, and electronic equipment | |
| CN108153806B (en) | Data migration | |
| CN111736884A (en) | Componentization method and system | |
| CN111427581B (en) | Method, device, equipment and medium for realizing type multi-inheritance | |
| CN116974581B (en) | Code generation method, device, electronic equipment and storage medium | |
| CN111176666B (en) | BIOS + ME mirror image refreshing method, system, equipment and readable medium | |
| CN112905263A (en) | Loading method and device of custom component, electronic equipment and storage medium | |
| CN110908644B (en) | Configuration method and device of state node, computer equipment and storage medium | |
| CN110018831B (en) | Program processing method, program processing apparatus, and computer-readable storage medium | |
| US10606612B2 (en) | Context check bypass to enable opening shared-object libraries | |
| US11550571B2 (en) | Generation of equivalent microservices to replace existing object-oriented application | |
| CN116048609A (en) | Configuration file updating method, device, computer equipment and storage medium | |
| CN113177292B (en) | Universal BIM secondary development implementation method and device | |
| CN112925523A (en) | Object comparison method, device, equipment and computer readable medium | |
| CN111221560B (en) | Resource management method and device and electronic equipment | |
| CN110502296B (en) | Method, equipment and storage medium for displaying firmware upgrading command | |
| US20210216526A1 (en) | Autonomous self-healing application data validation using database configurations | |
| CN112199080A (en) | Webpack construction method and equipment for vuejs project | |
| US11720333B2 (en) | Extending application lifecycle management to user-created application platform components |
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 | ||
| TR01 | Transfer of patent right |
Effective date of registration: 20230406 Address after: 250101 Inspur science and Technology Park, 1036 Inspur Road, hi tech Zone, Jinan City, Shandong Province Patentee after: Inspur Genersoft Co.,Ltd. Address before: 250100 Room 102, 1st floor, R & D building, 2877 Kehang Road, Suncun Town, high tech Zone, Jinan City, Shandong Province Patentee before: SHANDONG INSPUR GENESOFT INFORMATION TECHNOLOGY Co.,Ltd. |