CN111427581B - Method, device, equipment and medium for realizing type multi-inheritance - Google Patents

Method, device, equipment and medium for realizing type multi-inheritance Download PDF

Info

Publication number
CN111427581B
CN111427581B CN202010221672.0A CN202010221672A CN111427581B CN 111427581 B CN111427581 B CN 111427581B CN 202010221672 A CN202010221672 A CN 202010221672A CN 111427581 B CN111427581 B CN 111427581B
Authority
CN
China
Prior art keywords
class
merged
interface
super
superclasses
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
Application number
CN202010221672.0A
Other languages
Chinese (zh)
Other versions
CN111427581A (en
Inventor
张进
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Inspur General Software Co Ltd
Original Assignee
Shandong Inspur Genersoft Information Technology Co Ltd
Priority date (The priority date 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 date listed.)
Filing date
Publication date
Application filed by Shandong Inspur Genersoft Information Technology Co Ltd filed Critical Shandong Inspur Genersoft Information Technology Co Ltd
Priority to CN202010221672.0A priority Critical patent/CN111427581B/en
Publication of CN111427581A publication Critical patent/CN111427581A/en
Application granted granted Critical
Publication of CN111427581B publication Critical patent/CN111427581B/en
Active legal-status Critical Current
Anticipated expiration legal-status Critical

Links

Images

Classifications

    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00Arrangements for software engineering
    • G06F8/40Transformation of program code
    • G06F8/41Compilation

Landscapes

  • Engineering & Computer Science (AREA)
  • General Engineering & Computer Science (AREA)
  • Theoretical Computer Science (AREA)
  • Software Systems (AREA)
  • Physics & Mathematics (AREA)
  • General Physics & Mathematics (AREA)
  • Stored Programmes (AREA)

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 compilation, and configuring the combined class as an interface for extracting all 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

Method, device, equipment and medium for realizing type multi-inheritance
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 almost do not support one class to inherit multiple parent classes, 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 multiple inheritance, so that each method of a class can be developed and deployed separately.
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 of 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 multiple 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 extracting all the merged super classes further includes:
and finding interfaces of the merged classes and the merged super classes through the configuration files.
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 respectively corresponding to the superclasss of class transferring combination 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, where the computer program is executed by a processor to perform the foregoing method for implementing type multiple 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 embodiments or the prior art descriptions will be briefly described below, 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 according to 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 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 superclasses to be inherited;
s200, recording the superclass and an interface corresponding to the superclass;
s300, combining a plurality of superclasses into a combined class through dynamic compiling, and configuring the combined class as an interface for extracting all combined superclasses;
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 multiple inheritance of the present invention, recording the superclass and the interface corresponding to the superclass further comprises:
and recording the superclass and the interface corresponding to the superclass 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 multiple 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 extracting all the merged super classes further comprises:
and finding interfaces of the merged classes and the merged super classes through the configuration files.
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 multiple 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 extracting 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 SalesOrderService 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 a warehouse;
the ex-warehouse service provides the functions of setting confidentiality and ex-warehouse;
according to the requirements, related developers develop military sales order service on the basis of the sales order service, namely MilitarySOservice, and provide a function (SetSecureLevel) for setting the security level; the military warehousing service is developed on the basis of military sales order service and warehousing service, is named as MilitarySOGoodsReceiveService, and provides a security setting and warehousing function (SetSecureLevelAndGoodsRecive); the military export service is developed on the basis of military sales order service and export service, is named as MilitarySOGoodsIssueServer, and provides a function of setting privacy and exporting (SetSecureLevelAndGoodsIssue).
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 millitariysoodsireserviceimpl and the millitariysoodsisoseviceimpl are classes generated by dynamic compilation, they cannot be directly used by a service consumer, and thus a factory design pattern or the like is generally required to create an instance.
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 superclass and the interface corresponding to the superclass;
the merging module is configured to merge a plurality of superclasses into a merged class through dynamic compilation, and configure the merged class as an interface for extracting all the merged superclasses;
and the method transferring module is configured to combine the methods respectively corresponding to the superclasss of class transferring combination in response to the realization of the interface method.
According to some embodiments of the apparatus implementing type multiple inheritance according to the invention, the recording module is further configured to:
and recording the superclass and the interface corresponding to the superclass through the configuration file.
According to some embodiments of the apparatus for implementing type multiple inheritance according to the invention, the merging module is further configured to:
and finding interfaces of the merged classes and the merged super classes through the configuration files.
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 for implementing type inheritance as described above.
In another aspect of the embodiments of the present invention, a computer-readable storage medium is further provided, where a computer program is stored, where the computer program is executed by a processor to perform the foregoing method for implementing type multiple 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 this disclosure, no further discussion is repeated 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), or a Random Access Memory (RAM). The embodiments of the computer program may achieve the same or similar effects as any of the above-described method embodiments corresponding thereto.
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 as defined in the method disclosed by an embodiment 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 medium herein (e.g., memory) can be either volatile memory or nonvolatile memory, or can include both volatile and nonvolatile memory. By way of example, and not limitation, nonvolatile memory can include Read Only Memory (ROM), programmable ROM (PROM), electrically Programmable ROM (EPROM), electrically Erasable Programmable ROM (EEPROM), or flash memory. Volatile memory can include Random Access Memory (RAM), which can act as external cache memory. By way of example and not limitation, RAM is available in a variety of forms such as synchronous RAM (DRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), double data rate SDRAM (DDR SDRAM), enhanced SDRAM (ESDRAM), synchlink DRAM (SLDRAM), and Direct Rambus RAM (DRRAM). The storage devices of the disclosed aspects are intended to comprise, without being limited to, these and other suitable types of memory.
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 present disclosure.
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. If implemented in software, the functions may be stored on or transmitted over as one or more instructions or code on a computer-readable medium. Computer-readable media includes both computer storage media and communication media including any medium that facilitates transfer of a computer program from one place to another. A storage media may be any available media that can be accessed by a general purpose or special purpose computer. By way of example, and not limitation, such computer-readable media can comprise RAM, ROM, EEPROM, CD-ROM or other optical disk storage, magnetic disk storage or other magnetic storage devices, or any other medium that can be used to carry or store desired program code in the form of instructions or data structures and that can be accessed by a general-purpose or special-purpose computer, or a general-purpose or special-purpose processor. Also, any connection is properly termed a computer-readable medium. For example, if the software is transmitted from a website, server, or other remote source using a coaxial cable, fiber optic cable, twisted pair, digital Subscriber Line (DSL), or wireless technologies such as infrared, radio, and microwave, then the coaxial cable, fiber optic cable, twisted pair, DSL, or wireless technologies such as infrared, radio, and microwave are included in the definition of medium. Disk and disc, as used herein, includes Compact Disc (CD), laser disc, optical disc, digital Versatile Disc (DVD), floppy disk, blu-ray disc where disks usually reproduce data magnetically, while discs reproduce data optically with lasers. Combinations of the above should also be included within the scope of computer-readable media.
The foregoing are exemplary embodiments 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, where the above-mentioned storage medium may be a read-only memory, a magnetic disk or an optical disk.
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 (6)

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 transposes the methods that each correspond to the merged superclass;
wherein the interface for merging the plurality of superclasses into a merged class by dynamic compilation and configuring the merged class as a super class abstraction that implements all merges further comprises: finding the interfaces of the merged class and the merged super class through a configuration file; the dynamic compilation is achieved by microsoft, csharp, csharpcodeprovider or Roslyn in DotNet or javactiler in Java.
2. The method for implementing type multi-inheritance according to claim 1, wherein said recording of said super class and said interface corresponding to said super class further comprises:
and recording the super class and the interface corresponding to the super class through a configuration file.
3. An apparatus for implementing type multiple inheritance, wherein the apparatus comprises:
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 methods to which the merged superclass corresponds, in response to implementing an interface method, the merged class;
wherein the merge module is further configured to find the interfaces of the merged class and the merged super class from a configuration file; the dynamic compilation is implemented by Microsoft, CSharp, cschappProvider or Roslyn in DotNet or JavaCompailer in Java.
4. The apparatus for implementing type multiple inheritance according to claim 3, 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.
5. A computer device, comprising:
at least one processor; and
memory storing a computer program operable on the processor, characterized in that the processor, when executing the program, performs the method according to any of claims 1-2.
6. 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-2.
CN202010221672.0A 2020-03-26 2020-03-26 Method, device, equipment and medium for realizing type multi-inheritance Active CN111427581B (en)

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 CN111427581A (en) 2020-07-17
CN111427581B true 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)

Families Citing this family (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN111930363B (en) * 2020-08-07 2023-11-24 抖音视界有限公司 Block interface code generation method and device

Citations (5)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
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 广州视源电子科技股份有限公司 Method and device for parameter verification of interface, storage medium and electronic equipment
CN109960503A (en) * 2017-12-26 2019-07-02 北京金风科创风电设备有限公司 Component development method and device based on Django framework
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

Family Cites Families (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
JPH047640A (en) * 1990-04-25 1992-01-13 Hitachi Ltd Class succession settling processing method
US10528366B2 (en) * 2017-06-05 2020-01-07 International Business Machines Corporation Facilitating multi-inheritance within a single inheritance container-based environment
CN110232088B (en) * 2019-06-13 2021-03-26 华中师范大学 Method and device for classification merging and storage medium

Patent Citations (5)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
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 广州视源电子科技股份有限公司 Method and device for parameter verification of interface, storage medium and electronic equipment
CN109960503A (en) * 2017-12-26 2019-07-02 北京金风科创风电设备有限公司 Component development method and device based on Django framework
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)

* Cited by examiner, † Cited by third party
Title
Java代理模式;ALS Ritter;《https://alsritter.icu/posts/cffaadf/》;20200324;第1-14页 *

Also Published As

Publication number Publication date
CN111427581A (en) 2020-07-17

Similar Documents

Publication Publication Date Title
CN110032599B (en) Data structure reading and updating method and device, and electronic equipment
RU2725690C1 (en) Service processing method and device
JP2021534486A (en) Upgradeable securities tokens
CN110032568B (en) Data structure reading and updating method and device, and electronic equipment
US8141035B2 (en) Method for accessing internal states of objects in object oriented programming
CN111881102A (en) Method, device and readable medium for collecting audit logs based on AOP (automatic optical plane protocol) section
CN107025253A (en) A kind of method, database operation method and device for creating database interface
CN108153806B (en) Data migration
CN111427581B (en) Method, device, equipment and medium for realizing type multi-inheritance
CN111159301A (en) Data creating method, device, equipment and storage medium based on intelligent contract
CN116974581B (en) Code generation method, device, electronic equipment and storage medium
WO2002046909A1 (en) Automatically deploy and upgrade an application based on markup language application definition
CN111176666B (en) BIOS + ME mirror image refreshing method, system, equipment and readable medium
CN110059088A (en) Data attribute identification method, device and equipment in a kind of piece of chain type account book
CN112925523A (en) Object comparison method, device, equipment and computer readable medium
CN112379871A (en) Data processing method and device
CN110059087B (en) Data attribute identification method, device and equipment in block chain type account book
CN112114778A (en) Cross-platform dynamic library algorithm management system supporting horizontal extension
CN108021389B (en) Method and device for introducing ARouter into Android
CN115951870A (en) Mirror image file compiling method, system, equipment and medium
CN113779132B (en) Data importing method, device, computer equipment and storage medium
CN112817580B (en) Data processing method and device, electronic equipment and storage medium
CN102768721B (en) The method of control White List and device
CN111444215A (en) Blocking method, device and equipment in block chain type account book
CN111858558B (en) Application program modification method and device, readable storage medium and computer equipment

Legal Events

Date Code Title Description
PB01 Publication
PB01 Publication
SE01 Entry into force of request for substantive examination
SE01 Entry into force of request for substantive examination
GR01 Patent grant
GR01 Patent grant
TR01 Transfer of patent right

Effective date of registration: 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.

TR01 Transfer of patent right