CN114090128A

CN114090128A - Program running method, device, equipment and readable medium

Info

Publication number: CN114090128A
Application number: CN202111406301.0A
Authority: CN
Inventors: 刘永磊
Original assignee: Alipay Hangzhou Information Technology Co Ltd
Current assignee: Alipay Hangzhou Information Technology Co Ltd
Priority date: 2021-11-24
Filing date: 2021-11-24
Publication date: 2022-02-25

Abstract

The embodiment of the specification discloses a program running method, a program running device, a program running equipment and a readable medium. The scheme may include: the method comprises the steps that a first program obtains a call request of a second program for a common basic component; the public basic component is a preset component; determining a target component which needs to be called by the calling request from the common basic component; executing the target assembly to obtain an execution result; and returning the execution result to the second program.

Description

Program running method, device, equipment and readable medium

Technical Field

The present application relates to the field of computer technologies, and in particular, to a program running method, an apparatus, a device, and a computer-readable medium.

Background

In general, during the development of business projects, there is a need for the ability to have the project have a basis for, for example, the packaging of parameter objects, the handling of exceptions, the printing of logs, and the like. In actual development, each time a business project is developed, the basic capability needs to be developed, and the repeated development of the basic capability is time-consuming and labor-consuming, so that the development efficiency of the business project is reduced.

In view of the above, it is desirable to provide a method for improving the efficiency of research and development of business projects.

Disclosure of Invention

Embodiments of the present specification provide a program running method, an apparatus, a device, and a computer readable medium, so as to solve the problem that the efficiency of an existing business project research and development process is low.

In order to solve the above technical problem, the embodiments of the present specification are implemented as follows:

the program running method provided by the embodiment of the specification comprises the following steps:

the method comprises the steps that a first program obtains a call request of a second program for a common basic component; the public basic component is a preset component;

determining a target component which needs to be called by the calling request from the common basic component;

executing the target assembly to obtain an execution result;

and returning the execution result to the second program.

An embodiment of this specification provides a program running apparatus, including:

the calling request acquisition module is used for acquiring a calling request of a second program for the common basic component by the first program; the public basic component is a preset component;

the target component determining module is used for determining a target component which needs to be called by the calling request from the public basic component;

the target component execution module is used for executing the target component to obtain an execution result;

and the execution result returning module is used for returning the execution result to the second program.

An embodiment of this specification provides a program execution device, including:

at least one processor; and the number of the first and second groups,

a memory communicatively coupled to the at least one processor; wherein, the first and the second end of the pipe are connected with each other,

the memory stores instructions executable by the at least one processor to enable the at least one processor to:

acquiring a call request of a second program for the common basic component; the public basic component is a preset component;

executing the target assembly to obtain an execution result;

and returning the execution result to the second program.

The embodiment of the specification provides a computer readable medium, on which computer readable instructions are stored, the computer readable instructions can be executed by a processor to implement a program execution method:

executing the target assembly to obtain an execution result;

and returning the execution result to the second program.

One embodiment of the present description can achieve at least the following advantages: by presetting the basic common component, the corresponding target component to be called can be determined after the first program acquires the call request of the second program for the common basic component, and the execution result of the target component after execution is completed is returned to the second program.

Drawings

In order to more clearly illustrate the embodiments of the present disclosure 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, it is obvious that the drawings in the following description are only some embodiments described in the present application, and for those skilled in the art, other drawings can be obtained according to the drawings without any creative effort.

Fig. 1 is a schematic diagram of an application scenario of a service project establishment method provided in an embodiment of the present specification;

fig. 2 is a schematic diagram of establishment logic of a service project establishment method provided in an embodiment of the present specification;

FIG. 3 is a flow chart illustrating a method for executing a program according to an embodiment of the present disclosure;

fig. 4 is a schematic flowchart of program operation in an actual application scenario provided by an embodiment of the present disclosure;

FIG. 5 is a schematic structural diagram of a program execution device corresponding to FIG. 3 according to an embodiment of the present disclosure;

fig. 6 is a schematic structural diagram of a program execution device corresponding to fig. 3 provided in an embodiment of the present specification.

Detailed Description

To make the objects, technical solutions and advantages of one or more embodiments of the present disclosure more apparent, the technical solutions of one or more embodiments of the present disclosure will be clearly and completely described below with reference to specific embodiments of the present disclosure and the accompanying drawings. It is to be understood that the embodiments described are only a few embodiments of the present specification, and not all embodiments. All other embodiments that can be derived by a person skilled in the art from the embodiments given herein without making any creative effort fall within the protection scope of one or more embodiments of the present disclosure.

It is to be understood that, although the terms first, second, third, etc. may be used herein to describe various information, such information should not be limited by these terms. These terms are only used to distinguish one type of information from another.

In a general business project development process, basic capabilities such as parameter object packaging, exception handling, log printing and the like are all necessary. The ability to develop these foundations from scratch is time and labor intensive if each project is to be developed from scratch. In the prior art, it is common for business developers themselves to develop components with these basic capabilities. In the embodiments of the present specification, however, the business development side does not need to perform development of the common base component, but may directly use the common base component provided by the component development side.

The technical solutions provided by the embodiments of the present description are described in detail below with reference to the accompanying drawings.

Fig. 1 is a schematic diagram of an application scenario of a service project establishment method in an embodiment of the present specification.

As shown in FIG. 1, first, a component developer develops a common base component at a component development end; then, in the process of developing and developing a service processing framework aiming at the target service at a service developing end, a service developer can use a public basic component developed in advance by a component developing end; and then, the developed service processing framework can be issued to the service processing server, so that the service processing server can receive the service request of the service request end, respond to the service request, obtain a service request result after processing based on the service processing framework and return the service request result to the service request end.

In the method shown in fig. 1, a common basic component used in various specific services is developed in advance at a component development end. Typically, the functions that can be implemented by the common infrastructure component are ancillary functions in the business. In alternative embodiments, the common base component may include a unified wrapper component, a serialization component, an exception handling component, a log component, and the like. More specifically, the exception handling component may include an error code handling component, an exception handling component. The log components may include a summary log component, a business log component, a dependent service log component, a link context component, and the like.

In practical application, the common components in the embodiment of the specification are developed based on Java language. In particular, it may be developed based on the Spring framework. In particular practice, portal patterns, method interceptors, annotations, etc. may be used and provided to the business research end as a set of standard java components (i.e., jar packages).

In practical applications, the business development end may need to develop different business processing frameworks for different types of target businesses. For example, different types of target services may include login services, payment services, data query services, and so on. In a service processing framework for different target services, service core functions to be implemented may differ from each other, but auxiliary functions to be implemented may all be conventional functions. Therefore, as shown in the method of fig. 1, when the business development end is developing a business processing framework, on one hand, it is necessary to develop a business processing component for implementing core functions in the business for executing processing logic of the target business; on the other hand, the common base component that has been developed in advance can be directly used, for example, by referring to the dependent manner to realize the use of the common base component that has been developed in advance.

Fig. 2 is a schematic diagram illustrating a building logic of a service item building method provided in an embodiment of the present specification.

As shown in fig. 2, there may be a common base component that the component development side develops in advance for exception handling, log handling, wrapping, serialization. In the process of developing a service processing framework, a service development end needs to set a service side code for realizing the service. Specifically, at least a Facade class (Facade), a Facade class implementation Facade impl, needs to be set. In practical application, during the execution of the business-side code, the business assistance function can be realized by using a common basic component developed in advance. In the case of using a common base component provided by the component development side, the business development side needs to perform component-dependent configuration. For example, dependency information on the rcbase component needs to be configured. The business development end can selectively use the common basic components provided in advance. In addition, the service development end needs to configure a log file and intercept a packet path.

Therefore, based on the methods shown in fig. 1 and fig. 2, compared with the conventional research and development process in which the time-consuming and labor-consuming repeated research and development is performed on basic capabilities such as parameter object packaging, exception handling, log printing and the like, for the business research end, a pre-researched common basic component can be used through simple configuration, only business processing logic needs to be concerned, and the development process of the business processing framework is more efficient; moreover, the common basic components can encapsulate the basic capability, can be used under the condition of simple configuration and has no invasion to the business.

In an alternative embodiment, the business development end may comprise a legal review project development end. In practical application, the specific service item may include a content compliance verification item and the like. Based on the scheme of the embodiment of the specification, the code structure of the legal review center can be clear, and the research and development efficiency of the legal review center is improved.

Fig. 3 is a flowchart illustrating a program running method according to an embodiment of the present disclosure. From the viewpoint of the program, the execution subject of the flow may be a program installed in an application server or an application terminal.

As shown in fig. 3, the process may include the following steps:

step 302: the method comprises the steps that a first program obtains a call request of a second program for a common basic component; the common base component is a preset component.

In an embodiment of the present specification, the second program may be a program of a client role. For example, it may be a client program.

The first program may be a program module corresponding to an execution subject of the program execution method. In practical applications, the program module may be an integral part of a program for implementing the business item. In the program modules, a service processing component for implementing service core functions and a common base component for implementing auxiliary functions may be included.

Step 304: and determining a target component which needs to be called by the calling request from the common basic component.

In an embodiment of this specification, the obtaining, by the first program, a call request of the second program for the common base component may specifically include: and the facade role acquires a call request of the client role for the target subsystem. Correspondingly, the determining, from the common basic component, a target component that needs to be called by the call request may specifically include: and determining the target subsystem corresponding to the calling parameter as a target component to be called according to the calling parameter carried in the calling request.

In practice, in order to make the code structure more concise, a facade pattern may be employed. Three roles are included in the facade mode: a facade role and a subsystem role and a client role. In actual application, the client role calls the corresponding subsystem role through the facade role, and the subsystem role can realize the functions of the subsystem. In embodiments of the present description, various different common base component classes are encapsulated by setting a facade role class and serve as interfaces for client calls.

In actual application, the client can call the facade class, and the facade class can call the specific service processing class again. One facade class may call one or more service handling classes. In the embodiment of the present specification, optionally, the method in the service processing class corresponding to each common base component may be called through a facade class to implement a corresponding function. For example, various functions such as request log interception printing, authority interception processing, operation pipelining processing, business logic processing, exception processing, result log printing, result packaging and returning can be realized based on the call of the front interface.

Step 306: and executing the target assembly to obtain an execution result.

In an alternative embodiment, the common base component may include an exception handling component. Correspondingly, the executing the target component may specifically include: obtaining abnormal type information carried in the calling request; and executing an exception handling method corresponding to the exception type information based on the exception type information.

An exception is an exceptional event that occurs during program execution and interrupts the normal instruction stream of the program being executed. To be able to handle running errors in a program efficiently in time, exception classes may be used to make the program extremely fault tolerant and more robust. In an embodiment of the present specification, the exception handling component includes an exception class for handling a program run error.

During the running of a method, if an exception occurs to the method, the method will generate an object representing the exception and hand it to the runtime system (i.e., throw (throw) exception), whereby the runtime system will look up objects in the method's call stack that can handle this type of exception (i.e., catch exception).

In the embodiments of the present specification, the exception handling component that is preset includes an exception handling method.

In practice, as an example, a trycatch statement may be used to capture and handle exceptions. There may be a plurality of catch statements for matching and handling a plurality of different types of exceptions.

For example, the exception handling method in the embodiment of the present specification may include the following code structure:

in an alternative embodiment, the common base component may include a log component. Correspondingly, the executing the target component may specifically include: performing logging for at least one of a summary log, a traffic log, a dependent service log, or a link context; and/or performing log printing for at least one of a summary log, a traffic log, a dependent service log, or a link context.

The log is used for recording the running track of the program, so that key information can be conveniently searched, and the problem can be conveniently and quickly positioned and solved. Various attributes of the log system may be modified by editing the configuration file. By default, the configuration file exists under the jre installation directory "jre/lib/logging. The normal journal component will divide the journal into SEVERE, WARING, INFO, CONFIG, FINE, FINER, FINEST, and default to displaying only the journal with higher level than INFO.

In practice, log configuration needs to be done based on actual needs. In an embodiment of the present description, the log component may be preset by a component developer, and then configured in a configuration file by a business developer to use the preset log component. In embodiments of the present description, the log component may enable collection of various logs, such as summary logs, business logs, dependency layer logs, and the like. Optionally, the log component may be pre-developed by a component development end, and the business development end may use the pre-developed log component.

Specifically, the business development end can set configuration information in a configuration file for using the log component. More specifically, the configuration may be made in a properties file.

Further, in embodiments of the present specification, in order to collect the aforementioned log of various types, a method interceptor may be used.

Generally, an interceptor can dynamically intercept an object called by an Action, and provides a mechanism which enables a developer to execute a section of code before and after execution of an Action, can also prevent the execution of an Action before the execution of the Action, and also provides a way of extracting a reusable part of code in the Action. For example, in AOP, an interceptor may be used to intercept and then add certain operations before or after a certain method or field is accessed.

In embodiments of the present description, the interceptor may be provided by the component development end and referenced by the service development end, or may be developed by the service development end. In actual application, before the service development end applies the preset interceptor, declarations can be made in a configuration file, namely an xml file.

More specifically, in the process of applying the interceptor, the business development end can define an AOP cut-in point (Pointcut) based on the xml configuration file; alternatively, the AOP entry point may be defined based on annotations. After defining the entry point, intercepting the specified method may be implemented to generate a proxy object for the specified class.

As an example, some login verification method may be intercepted, for example, to record the request log prior to login. For another example, a login verification method may be intercepted to record an execution log of the login verification service after login verification. The examples given here are only examples, and the practical application scenarios are not limited to these.

In actual application, the system can be provided with an interceptor applied to log collection and an interceptor applied to authority verification.

As an example, a data modification method may be intercepted, for example, for permission verification before the data modification method is executed. For another example, a data modification method may be intercepted, so as to record an execution log of the data modification service after the data modification method is executed.

It can be understood that, in actual application, after the component developer provides various interceptor components, the business developer can set the specific method applied by the interceptor by setting the configuration information.

In an alternative embodiment, the common base component may include a rights management component. Correspondingly, the executing the target component may specifically include: acquiring requester information carried in the call request; and judging whether the requester has the method calling authority or not based on the requester information.

In an alternative embodiment, the common base component may comprise a packaging component. Correspondingly, the executing the target component may specifically include: acquiring data of a first specified type carried in the calling request; converting the first specified data type to a second specified data type using a method in the wrapper component.

Step 308: and returning the execution result to the second program.

It should be understood that in the method described in one or more embodiments of the present disclosure, the order of some steps may be adjusted according to actual needs, or some steps may be omitted.

According to the method in FIG. 3, by presetting the basic common component, after the first program obtains the call request of the second program for the common component, the corresponding target component to be called can be determined, and the execution result of the target component after execution is completed is returned to the called second program.

According to the above description, a schematic flow chart of program operation in an actual application scenario provided in the embodiments of the present specification is shown in fig. 4.

In fig. 4, a business processing framework for completing development provided by the embodiment of the present specification is shown. In the service processing framework, service processing components for implementing core service functions and common infrastructure components for implementing auxiliary service functions can be used.

As shown in fig. 4, when an external call request is received, the unified facade interface is called first, and after data is received, the received data is analyzed, and finally, an encapsulated analysis result is returned.

More specifically, as shown in the dashed box of fig. 4, are components packaged by the door facing to perform different functions. For example, a basic business processing component may be included that handles basic business logic, and basic common components such as a request log printing component, a permission processing component, an operation pipeline processing component, an exception handling component, a result log printing component, a result wrapping component, and the like may be included.

It should be noted that although this fig. 4 shows a plurality of basic common components as above, this is only illustrated as an example. In actual application, the business development end can selectively use one or more of the basic common components which are preset, and the specific execution sequence of each basic common component can be set according to actual needs.

In practice, which common infrastructure components are specifically used may depend on configuration information set by the business development end. Based on the same idea, the embodiment of the present specification further provides a device corresponding to the method. Fig. 5 is a schematic structural diagram of a program running apparatus corresponding to fig. 3 provided in an embodiment of the present disclosure. As shown in fig. 5, the apparatus may include:

a call request obtaining module 502, configured to obtain, by a first program, a call request of a second program for a common base component; the public basic component is a preset component;

a target component determining module 504, configured to determine, from the common base component, a target component that needs to be called by the call request;

a target component executing module 506, configured to execute the target component to obtain an execution result;

an execution result returning module 508, configured to return the execution result to the second program.

It will be appreciated that the modules described above refer to computer programs or program segments for performing a certain function or functions. In addition, the distinction between the above-described modules does not mean that the actual program code must also be separated.

Based on the same idea, the embodiment of the present specification further provides a device corresponding to the above method.

Fig. 6 is a schematic structural diagram of a program execution device corresponding to fig. 3 provided in an embodiment of this specification. As shown in fig. 6, the apparatus 600 may include:

at least one processor 610; and the number of the first and second groups,

a memory 630 communicatively coupled to the at least one processor; wherein the content of the first and second substances,

the memory 630 stores instructions 620 executable by the at least one processor 610 to enable the at least one processor 610 to:

executing the target assembly to obtain an execution result;

and returning the execution result to the second program.

Based on the same idea, the embodiment of the present specification further provides a computer-readable medium corresponding to the above method. The computer readable medium has computer readable instructions stored thereon that are executable by a processor to implement the method of:

executing the target assembly to obtain an execution result;

and returning the execution result to the second program.

While particular embodiments of the present specification have been described above, in some cases, the actions or steps recited in the claims may be performed in a different order than in the embodiments and still achieve desirable results. In addition, the processes depicted in the accompanying figures do not necessarily require the particular order shown, or sequential order, to achieve desirable results. In some embodiments, multitasking and parallel processing may also be possible or may be advantageous.

The embodiments in this specification are described in a progressive manner, and the same and similar parts among the embodiments can be referred to each other.

The apparatus, the device, and the method provided in the embodiments of the present specification are corresponding, and therefore, the apparatus and the device also have beneficial technical effects similar to those of the corresponding method, and since the beneficial technical effects of the method have been described in detail above, the beneficial technical effects of the corresponding apparatus and device are not described again here.

In the 90 s of the 20 th century, improvements in a technology could clearly distinguish between improvements in hardware (e.g., improvements in circuit structures such as diodes, transistors, switches, etc.) and improvements in software (improvements in process flow). However, as technology advances, many of today's process flow improvements have been seen as direct improvements in hardware circuit architecture. Designers almost always obtain the corresponding hardware circuit structure by programming an improved method flow into the hardware circuit. Thus, it cannot be said that an improvement in the process flow cannot be realized by hardware physical modules. For example, a Programmable Logic Device (PLD), such as a Field Programmable Gate Array (FPGA), is an integrated circuit whose Logic functions are determined by programming the Device by a user. A digital symbol system is "integrated" onto a PLD by the designer's own programming without requiring the chip manufacturer to design and fabricate a dedicated integrated circuit chip. Furthermore, nowadays, instead of manually making an Integrated Circuit chip, such Programming is often implemented by "logic compiler" software, which is similar to a software compiler used in program development and writing, but the original code before compiling is also written by a specific Programming Language, which is called Hardware Description Language (HDL), and HDL is not only one but many, such as abel (advanced Boolean Expression Language), ahdl (alternate Hardware Description Language), traffic, pl (core universal Programming Language), HDCal (jhdware Description Language), lang, Lola, HDL, laspam, hardward Description Language (vhr Description Language), vhal (Hardware Description Language), and vhigh-Language, which are currently used in most common. It will also be apparent to those skilled in the art that hardware circuitry that implements the logical method flows can be readily obtained by merely slightly programming the method flows into an integrated circuit using the hardware description languages described above.

The controller may be implemented in any suitable manner, for example, the controller may take the form of, for example, a microprocessor or processor and a computer-readable medium storing computer-readable program code (e.g., software or firmware) executable by the (micro) processor, logic gates, switches, an Application Specific Integrated Circuit (ASIC), a programmable logic controller, and an embedded microcontroller, examples of which include, but are not limited to, the following microcontrollers: the ARC625D, Atmel AT91SAM, Microchip PIC18F26K20, and Silicone Labs C8051F320, the memory controller may also be implemented as part of the control logic for the memory. Those skilled in the art will also appreciate that, in addition to implementing the controller as pure computer readable program code, the same functionality can be implemented by logically programming method steps such that the controller is in the form of logic gates, switches, application specific integrated circuits, programmable logic controllers, embedded microcontrollers and the like. Such a controller may thus be regarded as a hardware component and the means for performing the various functions included therein may also be regarded as structures within the hardware component. Or even means for performing the functions may be conceived to be both a software module implementing the method and a structure within a hardware component.

The systems, apparatuses, modules or units described in the above embodiments may be specifically implemented by a computer chip or an entity, or implemented by a product with certain functions. One typical implementation device is a computer. In particular, the computer may be, for example, a personal computer, a laptop computer, a cellular telephone, a camera phone, a smartphone, a personal digital assistant, a media player, a navigation device, an email device, a game console, a tablet computer, a wearable device, or a combination of any of these devices.

For convenience of description, the above devices are described as being divided into various units by function, and are described separately. Of course, the functionality of the various elements may be implemented in the same one or more pieces of software and/or hardware in the practice of the present application.

As will be appreciated by one skilled in the art, embodiments of the present invention may be provided as a method, system, or computer program product. Accordingly, the present invention may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present invention may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, and the like) having computer-usable program code embodied therein.

The present invention is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each flow and/or block of the flow diagrams and/or block diagrams, and combinations of flows and/or blocks in the flow diagrams and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.

These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including instruction means which implement the function specified in the flowchart flow or flows and/or block diagram block or blocks.

These computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide steps for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.

In a typical configuration, a computing device includes one or more processors (CPUs), input/output interfaces, network interfaces, and memory.

The memory may include forms of volatile memory in a computer readable medium, Random Access Memory (RAM) and/or non-volatile memory, such as Read Only Memory (ROM) or flash memory (flash RAM). Memory is an example of a computer-readable medium.

Computer-readable media, including both non-transitory and non-transitory, removable and non-removable media, may implement information storage by any method or technology. The information may be computer readable instructions, data structures, modules of a program, or other data. Examples of computer storage media include, but are not limited to, phase change memory (PRAM), Static Random Access Memory (SRAM), Dynamic Random Access Memory (DRAM), other types of Random Access Memory (RAM), Read Only Memory (ROM), Electrically Erasable Programmable Read Only Memory (EEPROM), flash memory or other memory technology, compact disc read only memory (CD-ROM), Digital Versatile Disks (DVD) or other optical storage, magnetic cassettes, magnetic tape disk storage or other magnetic storage devices, or any other non-transmission medium which can be used to store information which can be accessed by a computing device. As defined herein, computer readable media does not include transitory computer readable media (transmyedia) such as modulated data signals and carrier waves.

It should also be noted that the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising an … …" does not exclude the presence of other identical elements in the process, method, article, or apparatus that comprises the element.

The application may be described in the general context of computer-executable instructions, such as program modules, being executed by a computer. Generally, program modules include routines, programs, objects, components, data structures, etc. that perform particular tasks or implement particular abstract data types. The application may also be practiced in distributed computing environments where tasks are performed by remote processing devices that are linked through a communications network. In a distributed computing environment, program modules may be located in both local and remote computer storage media including memory storage devices.

The above description is only an example of the present application and is not intended to limit the present application. Various modifications and changes may occur to those skilled in the art to which the present application pertains. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present application should be included in the scope of the claims of the present application.

Claims

1. A program execution method comprising:

executing the target assembly to obtain an execution result;

and returning the execution result to the second program.

2. The method according to claim 1, wherein the obtaining, by the first program, the call request of the second program for the common base component specifically includes:

and the facade role acquires a call request of the client role for the target subsystem.

3. The method according to claim 2, wherein determining, from the common base component, a target component that the call request needs to call specifically comprises:

and determining the target subsystem corresponding to the calling parameter as a target component to be called according to the calling parameter carried in the calling request.

4. The method of claim 1, the common base component comprising an exception handling component;

the executing the target component specifically includes:

obtaining abnormal type information carried in the calling request;

and executing an exception handling method corresponding to the exception type information based on the exception type information.

5. The method of claim 1, the common base component comprising a log component;

the executing the target component specifically includes:

performing logging for at least one of a summary log, a traffic log, a dependent service log, or a link context;

and/or performing log printing for at least one of a summary log, a traffic log, a dependent service log, or a link context.

6. The method of claim 1, the common base component comprising a rights management component;

the executing the target component specifically includes:

acquiring requester information carried in the call request;

and judging whether the requester has the method calling authority or not based on the requester information.

7. The method of claim 1, the common base component comprising a packaging component;

the executing the target component specifically includes:

acquiring first specified type data carried in the call request;

converting the first specified data type to a second specified data type using a method in the wrapper component.

8. A program execution device comprising:

the calling request acquisition module is used for acquiring a calling request of a second program for the public basic component by the first program; the public basic component is a preset component;

9. A program execution device comprising:

at least one processor; and the number of the first and second groups,

a memory communicatively coupled to the at least one processor; wherein the content of the first and second substances,

executing the target assembly to obtain an execution result;

and returning the execution result to the second program.

10. A computer-readable medium having computer-readable instructions stored thereon, the computer-readable instructions being executable by a processor to implement the program execution method of any one of claims 1 to 7.