CN111796802A

CN111796802A - Function package generation method and device and electronic equipment

Info

Publication number: CN111796802A
Application number: CN202010617829.1A
Authority: CN
Inventors: 夏正冬; 谢将权
Original assignee: Beijing ByteDance Network Technology Co Ltd
Current assignee: Beijing ByteDance Network Technology Co Ltd
Priority date: 2020-06-30
Filing date: 2020-06-30
Publication date: 2020-10-20
Anticipated expiration: 2040-06-30
Also published as: CN111796802B

Abstract

The embodiment of the disclosure discloses a function package generation method and device and electronic equipment. One embodiment of the method comprises: determining a target packaging component to be called of a business interface component from at least two packaging components according to the type of a target function package in an issuing instruction, wherein the packaging component corresponds to the type of the function package, the packaging component is used for calling the business component, and the function package is used for being combined with an application program so that the application program can obtain a business function provided by the function package; and generating a target function package corresponding to the type of the target function package according to the service interface component, the target package component and the service component. Thus, a new way of generating a target function package is provided.

Description

Function package generation method and device and electronic equipment

Technical Field

The present disclosure relates to the field of internet technologies, and in particular, to a method and an apparatus for generating a function package, and an electronic device.

Background

With the development of the internet, users use more and more functions of terminal equipment, so that work and life are more convenient. With the increasingly large application program engineering and the increasing business, the componentization is a convenient engineering architecture. In some application scenarios, each service is taken as a component and independently developed and released. For example, a live application may have multiple components, such as a live component, a login component, a share component, a privacy component, and so forth. In order to reduce the size of the function package or realize dynamic updating of the components, some components can be pluged, and the default application package does not contain the service module plugins but downloads the service plugins as required when used by a user.

Disclosure of Invention

This disclosure is provided to introduce concepts in a simplified form that are further described below in the detailed description. This disclosure 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 method for generating a function package, where the method includes: determining a target packaging component to be called of a service interface component from at least two packaging components according to the type of a target function package in an issuing instruction, wherein the packaging component corresponds to the type of the function package, the packaging component is used for calling the service component, and the function package is used for being combined with an application program so that the application program can obtain a service function provided by the function package; and generating a target function packet corresponding to the type of the target function packet according to the service interface component, the target packaging component and the service component.

In a second aspect, an embodiment of the present disclosure provides a function package generating apparatus, including: the determining unit is used for determining a target packaging component to be called of the service interface component from at least two packaging components according to the type of the target function package in the issuing instruction, wherein the packaging component corresponds to the type of the function package, the packaging component is used for calling the service component, and the function package is used for being combined with the application program so that the application program can obtain the service function provided by the function package; and the generating unit is used for generating a target function package corresponding to the type of the target function package according to the service interface component, the target packaging component and the service component.

In a third aspect, an embodiment of the present disclosure provides an electronic device, including: one or more processors; storage means for storing one or more programs which, when executed by the one or more processors, cause the one or more processors to carry out the method according to the first aspect.

In a fourth aspect, embodiments of the present disclosure provide a computer readable medium having stored thereon a computer program which, when executed by a processor, implements the first aspect.

It should be noted that, by setting at least two kinds of wrapper components, different wrapper components call the service components to generate different types of function wrappers. Therefore, different function packages can be generated under the condition of developing one service component, the workload of developers is reduced, and the development period and the cost of the function packages are reduced.

Drawings

The above and other features, advantages and aspects of various embodiments of the present disclosure will become more apparent by referring to the following detailed description when taken in conjunction with the accompanying drawings. Throughout the drawings, the same or similar reference numerals denote the same or similar elements. It should be understood that the drawings are schematic and that elements and components are not necessarily drawn to scale.

FIG. 1 is a flow diagram for one embodiment of a feature pack generation method according to the present disclosure;

fig. 2 is a diagram of an application scenario in accordance with the present disclosure.

FIG. 3 is a schematic diagram of the structure of one embodiment of a rights control device according to the present disclosure;

FIG. 4 is an exemplary system architecture to which the feature pack generation method or the entitlement control method of one embodiment of the present disclosure may be applied;

fig. 5 is a schematic diagram of a basic structure of an electronic device provided according to an embodiment of the present 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 are shown in the 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 rather are provided for 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. Moreover, 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 "include" and its variants, as used herein, are intended to be inclusive, 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". Relevant definitions for other terms will be given in the following description.

It should be noted that the terms "first", "second", and the like in the present disclosure are only used for distinguishing different devices, modules or units, and are not used for limiting the order or interdependence relationship of the functions performed by the devices, modules or units.

It is noted that references to "a", "an", and "the" modifications in this disclosure are intended to be illustrative rather than limiting, and that those skilled in the art will recognize that "one or more" may be used unless the context clearly dictates otherwise.

The names of messages or information exchanged between devices in the embodiments of the present disclosure are for illustrative purposes only, and are not intended to limit the scope of the messages or information.

Referring to fig. 1, a flow diagram of one embodiment of a method of function package generation according to the present disclosure is shown. The function package generating method is applied to the server. The method for generating the function package as shown in fig. 1 comprises the following steps:

step 101, determining a target packaging component to be called of a service interface component according to the type of the target function package in the issuing instruction.

In this embodiment, an execution main body (for example, a server) of the function package generation method may determine, according to the type of the target function package in the issue instruction, a target wrapper component to be called by the service interface component.

In this embodiment, the execution agent may respond to an issue instruction from a user, and then perform a series of steps such as packaging, compiling, and the like to generate an execution generation target function package.

In this embodiment, the issue instruction may be used to instruct generation of the function package to be generated.

In some application scenarios, a user may enter publish mode information and then confirm the publication. The command body may acquire the type of the target function package according to the issue mode information input from the user after the user confirms the issue. The issue mode information and the operation of confirming the issue may be understood as an issue instruction. Since publishing is a conventional means in the field of computer software, it will not be described in detail herein.

Here, the feature pack is used in conjunction with an application program so that the application program can obtain the service features provided by the feature pack. The feature pack may be used to implement relatively independent features. The function package can have independent versions and can be independently compiled, tested, packaged and deployed. The function packet can be combined with the application through hot plug to expand the function of the application.

In some application scenarios, the function package may be called a function module, that is, the application is divided according to functions, and codes for implementing the same function are integrated together, so that the functions of the modules are relatively complex, but all belong to a single service. For example, the business modules (i.e., feature packs) may be divided into different types according to project function requirements, such as registration, login, takeout, live broadcast, and the like.

In this embodiment, the division of the function package type may be set according to the actual application scenario according to the specific type, and is not limited herein.

In some application scenarios, the above function package types may be divided according to different packaging and introduction manners. By way of example, the feature pack types may include, but are not limited to, at least one of: import library type (aar), plug-in type, jar (java archive) type.

In some application scenarios, jar contains a compiled class file and some text files containing metadata.

In some application scenarios, aar has more files than jar that are specific to Android, such as layout files, drawable files, and manifest files. In other words, an aar is a complete Module in Android.

In some application scenarios, a plug-in type may refer to a type of interaction with a host program through a plug-in. The plug-in type feature pack identifies itself by implementing an extended contract (usually an interface) specified by the host program, and receives event responses from the host program. And realizing interaction with the main program by turning the service provided by the main program.

In this embodiment, the required components may be published in the component repository in advance. Here, the kind of the distributed components may be set as needed, and is not limited herein.

Here, the component repository may be a project management and automation building tool, such as a Maven repository, Ivy repository. And the place where the component packages are stored in a centralized way is a component warehouse. The component warehouse can be placed locally or on a remote server. Either private or public.

In some application scenarios, business components and business interface components may be published in advance in a component repository.

In some application scenarios, the wrapper component may also be published in a component repository. The packaging assembly may be a generic term for various types of packaging assemblies.

In this embodiment, the service interface component may be an interface module provided by the functional component to the outside. Herein, externally may refer to other functional components in the application.

Here, the service interface component may define some parameters as per the convention with the host application. By way of example, the feature pack is a login feature pack, and the service interface component in the login feature pack may define parameters such as an account, password, and the like.

In this embodiment, the wrapper component may be used to call a service component, and the wrapper component may correspond to a function package type.

In some application scenarios, the wrapper component may include a first wrapper component and a second wrapper component. The first wrapper component may correspond to a reference library type. In some embodiments, the second packaging component may correspond to an insert type.

In this embodiment, the business component can be used to implement business functions. That is, a business component can be a core implementation component of business logic. This business component is invoked by either the first or second wrapper component.

By way of example, the business component can include a login component. The logon component may be used to implement the business logic of logging on.

In this embodiment, the wrapper component corresponding to the target function package type may be determined as the target wrapper component. As an example, if the target function package type in the issue instruction is an AAR type, the wrapper component corresponding to the AAR type may be determined as the target wrapper component.

And 102, generating a target function package corresponding to the target package type according to the service interface component, the target package component and the service component.

In this embodiment, the execution main body may issue the target function package corresponding to the target package type according to the service interface component, the target package component, and the service component.

Here, the execution body may establish a calling relationship in which the service interface component calls the target wrapper component, and establish a calling relationship in which the target wrapper component calls the service component. Then, the service interface component, the target packaging component and the component of the path of the service component are compiled to generate a target function package.

It should be noted that, in the method for generating a function package provided in this embodiment, at least two kinds of wrapper components are set, and different wrapper components call service components to generate different types of function packages. Therefore, different function packages can be generated under the condition of developing one service component, and as the different types of function packages can have different characteristics (such as whether hot update is available or not), the application can flexibly select the function package suitable for the application according to actual requirements. Therefore, the workload of developers can be reduced, and the development period and the cost of the function package can be reduced while various function packages are generated to flexibly meet the requirements.

In contrast, in some implementations, because each type of function package is coupled to the development framework more closely, different types of function packages are developed in an independent development manner. Therefore, the business components with the same function can have repeated labor among the development processes due to the fact that the development frameworks on which different types of function packages depend are different.

In some embodiments, the target function package is introduced by: determining a function package to be introduced according to the function package identification in the introduction relation information; and establishing a corresponding relation between the function package to be introduced and the target application.

In some application scenarios, the target function package may be published to a component repository by the execution agent after being generated. I.e. the target function package is also introduced as a component supply in the component repository.

In some application scenarios, a feature pack may be introduced by an application. The target function package introduced by the application may refer to that the electronic device in which the application runs may run the target function package, communication between the target function package and the application may be possible, and the target function package assists the application to implement the function of the target function package.

Here, the introduction relationship information may indicate a function package to be introduced. The introduction relationship information may be input by an application developer. The application developer can obtain the function package corresponding to the target application according to the requirement, and establish the relationship between the obtained function package and the target application.

In some application scenarios, the generated feature packages may include AAR-type feature packages and plug-in-type feature packages. An application (e.g., an application of an X application) developer may write, in the import relationship information, an identifier of a function package to be imported (e.g., a function package of an AAR type). Then, the electronic device used by the application developer can obtain the function package to be introduced, and establish the corresponding relationship between the function package of the AAR type and the X application. Therefore, the server side of the X application can issue the AAR type function package for the client side of the X application to download and install.

It should be noted that, the function package to be introduced is determined according to the function package identifier in the introduction relationship information, so that the application side can flexibly and conveniently switch the function package to be introduced. By way of example, the generated function packages may include an AAR-type function package and a plug-in-type function package, and an application developer (e.g., an X application) may conveniently switch between the AAR-type function package and the plug-in-type function package by modifying the function package identification in the import relationship information.

In some embodiments, the method may further include: and issuing the target function package to a component warehouse. Therefore, the target function package can be conveniently introduced into the client of the application by the application developer.

Referring to FIG. 2, an architecture diagram of components is shown.

In fig. 2, the service interface component 201 is an interface module provided externally by the functional package.

As an example, a login method may be defined in the service interface component.

In fig. 2, service component 202 is the core implementation module of the service logic of the service module, and is eventually called in both AAR mode and plug-in mode. Functional fields may be defined in the business components, interact with the server, and so on.

As an example, the core logic of login and server interaction, etc. may be defined in the business component.

In fig. 2, the first wrapper component 203 may be an outer wrapper class in an AAR manner, actually a calling service component.

In fig. 2, the second package component 204 may be an outer package class in a plug-in manner, the plug-in component 205 is a real plug-in module, and the plug-in component internally calls the service component. The first wrapping component and the plug-in component communicate with each other by means of Inter-Process Communication (IPC); by way of example, communication may be by way of adhesion (Binder) or reflection, etc.

Through the architecture shown in fig. 2, a service developer only needs to write service logic in a service component, and if an interface needs to be exposed to the outside, the service component needs to be implemented in a service interface component, a first package component, a second package component, and a plug-in component.

In some embodiments, the method further comprises: and issuing the first packaging component to a component warehouse, wherein the first packaging component corresponds to the type of the reference warehouse, and the first packaging component is used for calling the business component.

In some embodiments, the step 102 may include: in response to determining that the target wrapper component comprises a first wrapper component, establishing a calling relationship of the business interface component to the first wrapper component, and establishing a calling relationship of the first wrapper component to the business component; and generating a target function package comprising the service interface component, the first packaging component and the service component.

Here, the target wrapper component comprises a first wrapper component, which may be understood as including a reference library type in the issue instruction.

Referring to fig. 2, a target function package including a service interface component, a first wrapper component and a service component may be a function package along the

call path

201, 203 and 202.

It should be noted that, by publishing the first wrapper component to the component repository, the service interface component may be facilitated to refer to the first wrapper component to generate the target function package.

In some embodiments, the method may further include: issuing a plug-in component to a component repository, wherein the plug-in component is used for calling a business component; and issuing a second packaging component to the component warehouse, wherein the second packaging component corresponds to the plug-in type, and the second packaging component is used for calling the business component through the plug-in component.

In some embodiments, the step 102 may include: in response to determining that the target packaging component comprises a second packaging component, establishing a calling relationship of the business interface component to the second packaging component, establishing a calling relationship of the second packaging component to the plug-in component, and establishing a calling relationship of the plug-in component to the business component; and generating a target function package comprising a service interface component, a second packaging component, a plug-in component and a service component.

Here, the target wrapper component includes a first wrapper component, which may be understood as including a plug-in type in the issue instruction.

Referring to fig. 2, the target feature package including the service interface component, the second wrapper component, the plug-in component and the service component may be a feature package along the

call path

201, 204, 205 and 202.

It should be noted that, by publishing the second package component to the component repository, the business interface component may be facilitated to generate the target function package by referring to the second package component.

With further reference to fig. 3, as an implementation of the methods shown in the above-mentioned figures, the present disclosure provides an embodiment of a function package generating apparatus, which corresponds to the embodiment of the method shown in fig. 1, and which can be applied in various electronic devices.

As shown in fig. 3, the function package generating apparatus of the present embodiment includes: a determination unit 301 and a generation unit 302; the device comprises a determining unit, a service interface component and an application program, wherein the determining unit is used for determining a target packaging component to be called of the service interface component from at least two packaging components according to a target function package type in an issuing instruction, the packaging components correspond to the function package type, the packaging components are used for calling the service component, and the function package is used for being combined with the application program so that the application program can obtain a service function provided by the function package; and the generating unit is used for generating a target function package corresponding to the type of the target function package according to the service interface component, the target packaging component and the service component.

In this embodiment, specific processing of the determining unit 301 and the generating unit 302 of the function package generating apparatus and technical effects thereof can refer to related descriptions of step 101 and step 102 in the corresponding embodiment of fig. 1, which are not described herein again.

In some embodiments, the feature pack type comprises a reference library type; and the apparatus is further configured to: and issuing a first packaging component to the component warehouse, wherein the first packaging component corresponds to the type of the reference library, and the first packaging component is used for calling the business component.

In some embodiments, the generating a target function package corresponding to the target function package type according to the service interface component, the target wrapper component and the service component includes: in response to determining that the target wrapper component comprises a first wrapper component, establishing a calling relationship of the business interface component to the first wrapper component, and establishing a calling relationship of the first wrapper component to the business component; and generating a target function package comprising the service interface component, the first packaging component and the service component.

In some embodiments, the feature pack type comprises a plug-in type; and the apparatus is further configured to: issuing a plug-in component to a component repository, wherein the plug-in component is used for calling a business component; and issuing a second packaging component to the component warehouse, wherein the second packaging component corresponds to the plug-in type and is used for calling the plug-in component.

In some embodiments, the generating a target function package corresponding to the target function package type according to the service interface component, the target wrapper component and the service component includes: in response to determining that the target packaging component comprises a second packaging component, establishing a calling relationship of the business interface component to the second packaging component, establishing a calling relationship of the second packaging component to the plugin component, and establishing a calling relationship of the plugin component to the business component; and generating a target function package comprising the service interface component, the second packaging component, the plug-in component and the service component.

In some embodiments, the apparatus is further configured to: and issuing the target function package to a component warehouse.

Referring to fig. 5, fig. 5 illustrates an exemplary system architecture to which the feature pack generation method of one embodiment of the present disclosure may be applied.

As shown in fig. 5, the system architecture may include

terminal devices

501, 502, 503, a network 504, and a server 505. The network 504 serves to provide a medium for communication links between the

terminal devices

501, 502, 503 and the server 505. Network 504 may include various connection types, such as wired, wireless communication links, or fiber optic cables, to name a few.

The

terminal devices

501, 502, 503 may interact with a server 505 over a network 504 to receive or send messages or the like. The

terminal devices

501, 502, 503 may have various client applications installed thereon, such as a web browser application, a search-type application, and a news-information-type application. The client application in the

terminal device

501, 502, 503 may receive the instruction of the user, and complete the corresponding function according to the instruction of the user, for example, add the corresponding information in the information according to the instruction of the user.

The

terminal devices

501, 502, 503 may be hardware or software. When the

terminal devices

501, 502, 503 are hardware, they may be various electronic devices having a display screen and supporting web browsing, including but not limited to smart phones, tablet computers, e-book readers, MP3 players (Moving Picture Experts Group Audio Layer III, mpeg compression standard Audio Layer 3), MP4 players (Moving Picture Experts Group Audio Layer iv, mpeg compression standard Audio Layer 4), laptop portable computers, desktop computers, and the like. When the

terminal devices

501, 502, and 503 are software, they can be installed in the electronic devices listed above. It may be implemented as multiple pieces of software or software modules (e.g., software or software modules used to provide distributed services) or as a single piece of software or software module. And is not particularly limited herein.

The server 505 may be a server providing various services, for example, receiving an information acquisition request sent by the

terminal device

501, 502, 503, and acquiring the presentation information corresponding to the information acquisition request in various ways according to the information acquisition request. And the relevant data of the presentation information is sent to the

terminal devices

501, 502, 503.

It should be noted that the function package generating method provided by the embodiment of the present disclosure may be executed by a terminal device, and accordingly, the function package generating apparatus may be disposed in the

terminal device

501, 502, 503. In addition, the function package generation method provided by the embodiment of the present disclosure may also be executed by the server 505, and accordingly, a function package generation apparatus may be provided in the server 505.

It should be understood that the number of terminal devices, networks, and servers in fig. 4 is merely illustrative. There may be any number of terminal devices, networks, and servers, as desired for implementation.

Referring now to fig. 5, shown is a schematic diagram of an electronic device (e.g., a terminal device or a server of fig. 4) suitable for use in implementing embodiments of the present disclosure. The terminal device in the embodiments of the present disclosure may include, but is not limited to, a mobile terminal such as a mobile phone, a notebook computer, a digital broadcast receiver, a PDA (personal digital assistant), a PAD (tablet computer), a PMP (portable multimedia player), a vehicle terminal (e.g., a car navigation terminal), and the like, and a fixed terminal such as a digital TV, a desktop computer, and the like. The electronic device shown in fig. 5 is only an example, and should not bring any limitation to the functions and the scope of use of the embodiments of the present disclosure.

As shown in fig. 5, the electronic device may include a processing means (e.g., central processing unit, graphics processor, etc.) 501 that may perform various appropriate actions and processes according to a program stored in a Read Only Memory (ROM)502 or a program loaded from a storage means 508 into a Random Access Memory (RAM) 503. In the RAM 503, various programs and data necessary for the operation of the electronic apparatus 500 are also stored. The processing device 501, the ROM 502, and the RAM 503 are connected to each other through a bus 504. An input/output (I/O) interface 505 is also connected to bus 504.

Generally, the following devices may be connected to the I/O interface 505: input devices 506 including, for example, a touch screen, touch pad, keyboard, mouse, camera, microphone, accelerometer, gyroscope, etc.; output devices 507 including, for example, a Liquid Crystal Display (LCD), speakers, vibrators, and the like; storage devices 508 including, for example, magnetic tape, hard disk, etc.; and a communication device 509. The communication means 509 may allow the electronic device to communicate with other devices wirelessly or by wire to exchange data. While fig. 5 illustrates an electronic device having various means, it is to be understood that not all illustrated means are required to be implemented or provided. More or fewer devices may alternatively be implemented or provided.

In particular, according to an embodiment of the present disclosure, the processes described above with reference to the flowcharts may be implemented as computer software programs. For example, embodiments of the present disclosure include a computer program product comprising a computer program carried on a non-transitory computer readable medium, the computer program containing program code for performing the method illustrated by the flow chart. In such embodiments, the computer program may be downloaded and installed from a network via the communication means 509, or installed from the storage means 508, or installed from the ROM 502. The computer program performs the above-mentioned functions defined in the method of the embodiments of the present disclosure when executed by the processing device 501.

It should be noted that the computer readable medium in the present disclosure can be a computer readable signal medium or a computer readable storage medium or any combination of the two. A computer readable storage medium may be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination 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 present 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 contrast, in the present disclosure, a computer readable signal medium may include a propagated data signal with computer readable program code embodied therein, either in baseband or as part of a carrier wave. 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 thereof. 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, optical cables, RF (radio frequency), etc., or any suitable combination of the foregoing.

In some embodiments, 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 communications 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 network.

The computer readable medium may be embodied in the electronic device; or may exist separately without being assembled into the electronic device.

The computer readable medium carries one or more programs which, when executed by the electronic device, cause the electronic device to: determining a target packaging component to be called of a business interface component from at least two packaging components according to the type of the target function package in the issuing instruction, wherein the packaging component corresponds to the type of the function package and is used for calling the business component;

and generating a target function package corresponding to the type of the target function package according to the service interface component, the target package component and the service component. The computer readable medium carries one or more programs which, when executed by the electronic device, cause the electronic device to: receiving a live stream acquisition request; and determining whether to return the live stream or not according to the live stream acquisition request.

Computer program code for carrying out operations for the present disclosure may be written in any combination of 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 type of network, including a Local Area Network (LAN) or a Wide Area Network (WAN), or the connection may be made to an external computer (for example, through the Internet using an Internet service provider).

The flowchart 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 units described in the embodiments of the present disclosure may be implemented by software or hardware. Where the name of a unit does not in some cases constitute a limitation on the unit itself, for example, the determination unit may also be described as a "unit that determines the target wrapper component to be invoked by the service interface component".

The functions described herein above 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: field Programmable Gate Arrays (FPGAs), Application Specific Integrated Circuits (ASICs), Application Specific Standard Products (ASSPs), systems on a chip (SOCs), Complex Programmable Logic Devices (CPLDs), 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. A 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 may 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.

The foregoing description is only exemplary of the preferred embodiments of the disclosure and is illustrative of the principles of the technology employed. It will be appreciated by those skilled in the art that the scope of the disclosure herein is not limited to the particular combination of features described above, but also encompasses other embodiments in which any combination of the features described above or their equivalents does not depart from the spirit of the disclosure. For example, the above features and (but not limited to) technical features having similar functions disclosed in the present disclosure are mutually replaced to form the technical solution.

Further, while 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. Under 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 limitations on the scope of the 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 disclosed as example forms of implementing the claims.

Claims

1. A method for generating a function package, comprising:

determining a target packaging component to be called of a business interface component from at least two packaging components according to the type of a target function package in an issuing instruction, wherein the packaging component corresponds to the type of the function package, the packaging component is used for calling the business component, and the function package is used for being combined with an application program so that the application program can obtain a business function provided by the function package;

and generating a target function package corresponding to the type of the target function package according to the service interface component, the target package component and the service component.

2. The method of claim 1, wherein the function package type comprises a reference library type, and wherein the at least two including components comprise a first wrapper component, the first wrapper component corresponding to the reference library type; and

the method further comprises the following steps:

the first packaged component is published to a component repository.

3. The method of claim 2, wherein generating the target function package corresponding to the target function package type according to the service interface component, the target wrapper component and the service component comprises:

in response to determining that the target wrapper component comprises a first wrapper component, establishing a calling relationship of the business interface component to the first wrapper component, and establishing a calling relationship of the first wrapper component to the business component;

and generating a target function package comprising the service interface component, the first packaging component and the service component.

4. The method of claim 1, wherein the feature pack type comprises a plug-in type, and wherein the at least two including components comprise a second wrapper component, the second wrapper component corresponding to the plug-in type; and

the method further comprises the following steps:

issuing a plug-in component to a component repository, wherein the plug-in component is used for calling a business component;

and issuing a second packaging component to the component warehouse, wherein the second packaging component is used for calling the business component through the plug-in component.

5. The method of claim 4, wherein generating the target function package corresponding to the target function package type according to the service interface component, the target wrapper component and the service component comprises:

in response to determining that the target packaging component comprises a second packaging component, establishing a calling relationship of the business interface component to the second packaging component, establishing a calling relationship of the second packaging component to the plugin component, and establishing a calling relationship of the plugin component to the business component;

and generating a target function package comprising the service interface component, the second packaging component, the plug-in component and the service component.

6. The method of claim 5, further comprising:

and issuing the target function package to a component warehouse.

7. The method according to any of claims 1-6, wherein the target function package is introduced by:

determining a function package to be introduced according to the function package identification in the introduction relation information;

and establishing a corresponding relation between the function package to be introduced and the target application.

8. A function pack generation apparatus, comprising:

the device comprises a determining unit, a service interface component and a service component, wherein the determining unit is used for determining a target packaging component to be called of the service interface component from at least two packaging components according to a target function package type in an issuing instruction, the packaging component corresponds to the function package type, the packaging component is used for calling the service component, and the function package is used for being combined with an application program so that the application program can obtain a service function provided by the function package;

and the generating unit is used for generating a target function package corresponding to the type of the target function package according to the service interface component, the target packaging component and the service component.

9. The apparatus of claim 8, wherein the target function package is introduced by:

10. An electronic device, comprising:

one or more processors;

a storage device for storing one or more programs,

when executed by the one or more processors, cause the one or more processors to implement the method of any one of claims 1-7.

11. A computer-readable medium, on which a computer program is stored which, when being executed by a processor, carries out the method according to any one of claims 1 to 7.