CN113296740A

CN113296740A - Service object processing method, device, equipment and machine readable medium

Info

Publication number: CN113296740A
Application number: CN202011376584.4A
Authority: CN
Inventors: 杨敏; 裘鑫; 许晓
Original assignee: Alibaba Group Holding Ltd
Current assignee: Alibaba Group Holding Ltd
Priority date: 2020-11-30
Filing date: 2020-11-30
Publication date: 2021-08-24

Abstract

The embodiment of the application provides a method, a device, equipment and a machine readable medium for processing a service object, wherein the method comprises the following steps: providing a development tool of a service object corresponding to the workbench; determining a service code matching the development tool; and associating the service code with a corresponding service party so as to customize the workbench of the service party. According to the embodiment of the application, the expansion of the service process of the workbench where the service party is located can be realized, and the customization of the service object can be realized in the service process, so that the personalized customization requirement can be realized, and the expansion of the service capability can be further realized.

Description

Service object processing method, device, equipment and machine readable medium

Technical Field

The present application relates to the field of communications technologies, and in particular, to a method for processing a service object, a device for processing a service object, and a machine-readable medium.

Background

With the development of communication technology, in order to manage the relationship between an enterprise and a user, the enterprise generally provides services, such as services related to marketing, technical support, disputes, and the like, to the user through a network.

In order to support the enterprise to develop the third party Application for the user service, the current open platform may open an API (Application Programming Interface) for the enterprise to call. Enterprises can apply open platform open service capabilities in their integrated environments to provide services to users.

In the process of implementing the embodiment of the present application, the inventor finds that the service capability opened by the open platform is relatively standard, which makes the third-party application provide relatively universal service and cannot meet personalized service requirements. However, to improve service efficiency, different enterprises often have different service requirements. For example, different enterprises have different requirements for pages or page elements. Alternatively, the enterprise needs to interact with its own service system to provide service information such as member information and order information.

Disclosure of Invention

The technical problem to be solved by the embodiments of the present application is to provide a method for processing a service object, which can implement extension of a service flow of a workbench where a service provider is located, and implement customization of the service object in the service flow, thereby implementing personalized customization requirements, and further implementing extension of service capabilities.

Correspondingly, the embodiment of the application also provides a processing device, equipment and a machine readable medium of the service object, which are used for ensuring the realization and the application of the method.

In order to solve the above problem, an embodiment of the present application discloses a method for processing a service object, including:

providing a development tool of a service object corresponding to the workbench;

determining a service code matching the development tool;

and associating the service code with a corresponding service party so as to customize the workbench of the service party.

receiving a use request aiming at a service object corresponding to the workbench; the service code of the service object is associated with a corresponding service party;

and calling the service code of the service object according to the use request.

On the other hand, the embodiment of the application also discloses a service object processing method, which comprises the following steps:

providing a development tool of a page corresponding to the workbench;

determining a service code matching the development tool;

providing a development tool of a service directory corresponding to the workbench;

determining a service code matching the development tool;

registering the service corresponding to the service code to a service directory; the service code is obtained according to a development tool of the service object corresponding to the workbench;

establishing a mapping relation between services in a service directory and a service party;

receiving a service request; the service request includes: requesting a service party;

if the service request party is matched with the service party in the mapping relation, the service code of the service corresponding to the service request party is called in the service flow of the workbench corresponding to the service request party.

and if the request service party is matched with the service party in the mapping relation, determining an access address of a service code of the service corresponding to the request service party, so as to call the service code according to the access address.

calling a service code in a service flow of a workbench corresponding to a service party; the service code is obtained according to a development tool of the service object corresponding to the workbench;

and charging the service party according to the calling information of the service code.

and charging the service party according to the resources consumed by the operation of the service codes.

providing an interface of a workbench; the interface comprises: at least one window; the window includes: at least one government object;

sending a use request corresponding to a target government affair object according to a trigger operation of a user for the target government affair object so as to provide a service corresponding to the target government affair object for the user; and the service code is obtained according to a development tool of the target government affair object.

receiving a use request corresponding to a target government affair object in a workbench;

calling a service code corresponding to the target government affair object; and the service code is obtained according to a development tool of the target government affair object.

In another aspect, an embodiment of the present application further discloses a device for processing a service object, including:

the providing module is used for providing a development tool of the service object corresponding to the workbench;

the determining module is used for determining the service codes matched with the development tools;

and the association module is used for associating the service code with the corresponding service party so as to call the service code in the service flow of the service party.

a request receiving module for receiving a use request for a service object; the service code of the service object is associated with the service flow of the workbench corresponding to the service party;

and the code calling module is used for calling the service code of the service object according to the use request.

In another aspect, an embodiment of the present application further discloses an apparatus, including:

one or more processors; and

one or more machine-readable media having instructions stored thereon, which when executed by the one or more processors, cause the apparatus to perform one or more of the methods described above.

In yet another aspect, embodiments of the present application disclose one or more machine-readable media having instructions stored thereon, which when executed by one or more processors, cause an apparatus to perform one or more of the aforementioned methods.

The embodiment of the application has the following advantages:

the development tool provided by the embodiment of the application can be used for developing the service object corresponding to the workbench to obtain the service code matched with the development tool. The service code described above may be used to implement customized service objects. The service code is associated with the corresponding service party, and a customized workbench can be provided for the service party. Because the workbench of the server side comprises the customized service object, the customization requirement of the service object can be realized, and the expansion of the service capability can be further realized.

Drawings

FIG. 1 is an illustration of a customer service page in an embodiment of the present application;

FIG. 2 is a flowchart illustrating a first embodiment of a method for processing a service object according to the present application;

FIG. 3 is an illustration of an application environment of a method for processing a service object according to an embodiment of the disclosure;

FIG. 4 is an illustration of a micro-application based processing of service objects in accordance with the subject application;

FIG. 5 is a schematic illustration of a process for a micro-application of an embodiment of the present application;

FIG. 6 is a schematic illustration of a process flow for a service of an embodiment of the present application;

FIG. 7 is a block diagram of a system for processing a service object according to an embodiment of the present application;

FIG. 8 is a schematic of a health monitoring process in an embodiment of the present application;

FIG. 9 is a flowchart illustrating a page-type micro application process according to an embodiment of the present application;

FIG. 10 is a flow chart illustrating the processing of a plug-in type micro application according to an embodiment of the present application;

FIG. 11 is a flowchart illustrating a third embodiment of a method for processing a service object according to the present application;

FIG. 12 is a schematic diagram of an engine for operation according to an embodiment of the present application;

FIG. 13 is a flowchart illustrating a fourth embodiment of a method for processing a service object according to the present application;

FIG. 14 is a flowchart illustrating a fifth embodiment of a method for processing a service object according to the present application;

FIG. 15 is a flowchart illustrating steps of a sixth embodiment of a method for processing a service object according to the present application;

FIG. 16 is a flowchart illustrating a seventh embodiment of a method for processing a service object according to the present application;

FIG. 17 is a flowchart illustrating the processing steps of an eighth embodiment of a method for processing a service object according to the present application;

FIG. 18 is a flowchart illustrating the steps of a ninth embodiment of a method for processing a service object according to the present application;

FIG. 19 is a block diagram of an embodiment of a service object processing device according to the present application;

FIG. 20 is a block diagram of an embodiment of a service object processing apparatus according to the present application;

FIG. 21 is an exemplary device 2500 that can be used to implement the various embodiments described above in this application;

FIG. 22 is a flowchart illustrating the steps of one embodiment of a method for processing a service object;

FIG. 23 is an illustration of a window of an embodiment of the present application; and

FIG. 24 is a flowchart illustrating the steps of an eleventh embodiment of a method for processing a service object according to the present application; .

Detailed Description

In order to make the aforementioned objects, features and advantages of the present application more comprehensible, the present application is described in further detail with reference to the accompanying drawings and the detailed description.

The technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the drawings in the embodiments of the present application, and it is obvious that the described embodiments are only a part of the embodiments of the present application, and not all of the embodiments. All other embodiments that can be derived from the embodiments given herein by a person of ordinary skill in the art are intended to be within the scope of the present disclosure.

While the concepts of the present application are susceptible to various modifications and alternative forms, specific embodiments thereof have been shown by way of example in the drawings and will herein be described in detail. It should be understood, however, that the description above is not intended to limit the application to the particular forms disclosed, but on the contrary, the intention is to cover all modifications, equivalents, and alternatives falling within the spirit and scope of the application.

Reference in the specification to "one embodiment," "an embodiment," "a particular embodiment," or the like, means that the embodiment described may include a particular feature, structure, or characteristic, but every embodiment may or may not necessarily include the particular feature, structure, or characteristic. Moreover, such phrases are not necessarily referring to the same embodiment. Further, where a particular feature, structure, or characteristic is described in connection with an embodiment, it is submitted that it is within the knowledge of one skilled in the art to affect such feature, structure, or characteristic in connection with other embodiments whether or not explicitly described. In addition, it should be understood that items in the list included in the form "at least one of a, B, and C" may include the following possible items: (A) (ii) a (B) (ii) a (C) (ii) a (A and B); (A and C); (B and C); or (A, B and C). Likewise, a listing of items in the form of "at least one of a, B, or C" may mean (a); (B) (ii) a (C) (ii) a (A and B); (A and C); (B and C); or (A, B and C).

In some cases, the disclosed embodiments may be implemented as hardware, firmware, software, or any combination thereof. The disclosed embodiments may also be implemented as instructions carried or stored on one or more transitory or non-transitory machine-readable (e.g., computer-readable) storage media, which may be executed by one or more processors. A machine-readable storage medium may be implemented as a storage device, mechanism, or other physical structure (e.g., a volatile or non-volatile memory, a media disk, or other media other physical structure device) for storing or transmitting information in a form readable by a machine.

In the drawings, some structural or methodical features may be shown in a particular arrangement and/or ordering. Preferably, however, such specific arrangement and/or ordering is not necessary. Rather, in some embodiments, such features may be arranged in different ways and/or orders than as shown in the figures. Moreover, the inclusion of structural or methodical features in particular figures is not meant to imply that such features are required in all embodiments and that, in some embodiments, such features may not be included or may be combined with other features.

In the embodiment of the application, the workbench can represent a platform for providing services. The service object may represent a tool object that the workbench stands alone in providing the service. A workbench can correspond to a plurality of service objects. Different service objects may correspond to different service requirements.

The service object may be related to the provided page content or the service object may be related to the provided functionality. The service objects of the embodiments of the present application may include, but are not limited to: pages, plug-ins, plug-in views, service directories and callback objects, etc.

Conventional techniques may provide a standard or universal workstation for different service providers. The embodiment of the application can support the service party to customize the service object corresponding to the workbench, and the customized service object is associated with the workbench of the service party, so that personalized service capability is provided according to the customized service object in the service process of the service party.

The page can represent a frame, which can be a large frame or a small frame in the large frame.

Referring to fig. 1, a schematic diagram of a customer service page in the embodiment of the present application is shown, which may specifically include: navigation, membership lists, dialog information, input areas, plug-ins, etc.

The page in the embodiment of the present application may correspond to the entire customer service page corresponding to fig. 1, or may correspond to a customized page corresponding to the navigation portion in fig. 1.

The page may be a left navigation page in a customer service workbench, which may include at least one front-end component; alternatively, it may include: at least one front-end component on the left side and a plug-in on the right side, wherein the plug-in area on the right side may be referred to as the plug-in area.

The method and the device for customizing the page can support the server to customize the page so as to provide more information related to the server for the user. For example, the page may be a homepage of a platform corresponding to the service party, and it can be understood that the service party may determine the specific content of the page according to the actual application requirement.

Plug-in is a program written in an application program interface that complies with a certain specification. The plug-in may be a front-end component supported by the customer service workbench framework that may be dynamically loaded into the plug-in section of the page.

As shown in fig. 1, the insert part may include: a generic plug-in and a customized plug-in. The service side can interact with the service system of the service side according to the customized plug-in so as to provide service information such as member information, order information and the like.

And the plug-in view can represent the presentation style of the plug-in. The presentation style may include: graphics, text, etc. The service side can determine the specific display style of the plug-in according to the actual application requirement.

And the service directory can provide customized services in the form of services. The service directory may include: utilizing service objects provided by the facility. The facility may be a software facility with processing capabilities, which may include, but is not limited to: short message facilities, robot facilities, quality inspection facilities, voice navigation facilities and the like. The robot facility can be used for carrying out intelligent interaction with the user, the quality inspection facility can be used for detecting the quality of manual service, and the voice navigation facility can guide the user to operate in a voice mode.

The workbench can provide general services according to general facilities in a general service flow. For example, with a generic robot facility (referred to as a first robot facility), intelligent interaction is performed with the user.

According to the embodiment of the application, the personalized service directory can be provided according to the data of the service party. For example, the server a trains a robot facility (referred to as a second robot facility) that is more matched with its own application scenario by using its own user data, and the intelligent interaction performance of the second robot facility is higher, so the server a can customize the second robot facility and apply it to a general service flow.

The embodiment of the application can provide personalized voice navigation service. According to one embodiment, different voice navigation services may be provided depending on the identity of the user. For example, the membership corresponds to the voice navigation service 1, the non-membership corresponds to the voice navigation service 2, and so on.

According to one embodiment, voice navigation services of different target languages can be provided according to the geographic position information of the user. The target language may be matched with the geographic location information. For example, if the geographic location information corresponds to Chinese, the target language is Chinese; or, if the geographic location information corresponds to the united kingdom, the target language is english, etc.

And the callback object can callback the system event message to the service party. For example, an event message of the user closing the work order is called back to the service side, and the like, so that the requirement of the service side for acquiring the system event can be met.

The embodiment of the application provides a processing scheme of a service object, which specifically comprises the following steps: providing a development tool for the service object; determining a service code matching the development tool; and associating the service code with a corresponding service party so as to customize the workbench of the service party.

The development tool provided by the embodiment of the application can be used for developing the service object so as to obtain the service code matched with the development tool. The service code described above may be used to implement customized service objects. The service code is associated with the corresponding service party, and a customized workbench can be realized. Because the workbench of the server side comprises the customized service object, the customization requirement of the service object can be realized, and the expansion of the service capability can be further realized.

The developer of the embodiment of the present application may be a service side, or may be an Independent Software developer (ISV). The developer can concentrate on writing the service code without paying attention to the running information of the service code, so that the customization efficiency of the service object can be improved. The operation information may include: operation mode and operation stability, etc.

The embodiment of the present application does not limit the providing manner or the providing subject of the general service flow in the workbench. For example, the processing platform of the embodiment of the present application may provide a general service flow to provide general service capabilities. Or, the processing platform of the embodiment of the present application may open an API for a service party to call, and the service party may apply the service capability opened by the processing platform to its own integrated environment to provide a general service flow.

The service provider of the embodiment of the application can represent the service provider. Different service scenarios may correspond to different service parties. The application scenario may include: e-commerce scenes, social scenes, instant messaging scenes, search scenes, question and answer scenes and the like. The service party can customize the service object according to the characteristics of the application scene so as to meet the personalized customization requirement. For example, a service provider of an e-commerce scenario may utilize a customized workstation to provide customized services to a user.

For example, the service party may provide a membership service. The member service information of the e-market scene may include: member identification, member rating, member's historical orders, etc. And the member service information of the social scenario may include: member identification, member level, member's historical posts, etc.

The processing platform of the embodiment of the application can define a development tool corresponding to the service object, for example, a service party of an enterprise develops a service code corresponding to the service object through the development tool, and registers the service code into a service flow corresponding to the service party, thereby realizing customization of a workbench of the service party. During the use process of enterprise users, services are provided for the users through the instances of service objects developed by the enterprises.

The service object in the workbench is abstracted, the service object is customized in a unit, and the customization requirements of different service parties for different service objects can be met.

Method embodiment one

Referring to fig. 2, a flowchart illustrating a first step of a first embodiment of a method for processing a service object according to the present application is shown, where the method may specifically include the following steps:

step 201, providing a development tool of a service object corresponding to a workbench;

step 202, determining a service code matched with the development tool;

and step 203, associating the service code with a corresponding service party so as to customize the workbench of the service party.

The method of the embodiment of the application can be used for customizing the service object and the workbench. At least one step included in the method of the embodiments of the present application may be performed by a processing platform. The processing platform can provide customized service objects and workstations for the service provider. It is to be understood that the embodiments of the present application are not limited to the particular implementation of the methods.

Referring to fig. 3, a schematic diagram of an application environment of a service object processing method according to an embodiment of the present application is shown, where a processing platform may provide a development tool of a service object corresponding to a workbench, a service party may develop a service code according to the development tool, and the processing platform may further associate the service code with the corresponding service party to customize the workbench of the service party. In this way, in the process that the user uses the service flow of the service party, the processing platform can call the service code customized by the service party to provide the personalized service corresponding to the service object for the user.

In step 201, a development tool may be used to develop a service object.

Optionally, the development tools may include, but are not limited to: development kits such as command line tools, Integrated Development Environment (IDE) plug-ins, Software Development Kit (SDK), etc., it is understood that the embodiments of the present application are not limited to the specific form of the Development tools.

In an optional embodiment of the present application, an interface corresponding to the service object may also be provided. The interface may define a protocol corresponding to the service object to implement communication interaction in the implementation process of the service object.

Different types of service objects may correspond to different interfaces. The types of service objects may include: pages, plug-ins, plug-in views, service directories and callback objects, etc.

The interface of the service object may include: the function of the service object can be defined so that the service side supplements the concrete implementation of the function.

Optionally, the interface may include: the data of the service side corresponds to an interface so as to utilize the data of the service side in the service code. The data of the service side may include: order data, member data, or user behavior data, etc., to enable the service code to provide personalized services according to the data of the service provider.

Alternatively, information of data of the service side may be used as a parameter of the interface. Taking the member object as an example, the corresponding interface may include: input parameters, output parameters and service methods, such that the service party embodies the input parameters, the output parameters and the service methods. For example, the service corresponding to the member object is a member service, the input parameter may be a member identifier such as a mobile phone number, and different service parties may use different service methods to obtain different types of member information. The different service methods may include: different member databases are accessed. The member information of different kinds may include: member ratings, historical orders for members, different information in historical postings for members, etc.

The method and the device for developing the service object can respond to the customization request of the service object and provide the development tool of the service object. The customization request may include information such as a type of the service object, and the embodiment of the present application may provide a development tool corresponding to the type.

In step 202, the service code may be used to implement the processing logic of the service object. The processing logic may include: loading logic and response logic of pages, plug-ins or service directories, processing logic of membership objects, or triggering logic and calling methods of callback objects, etc.

Optionally, the embodiments of the present application may provide a code template, such as an open source framework code template of Java, or a running framework code template of JavaScript (interpreted or just-in-time compiled high-level programming language). The code template can help a user to write the service code, so that the writing efficiency of the service code can be improved, and the customizing efficiency of the service object can be further improved.

In an optional embodiment of the present application, the determining the service code of the service object specifically includes: providing a code template corresponding to the development tool; and receiving the service code matched with the code template. Of course, the service code may be determined without providing a code template, and the specific determination manner of the service code is not limited in the embodiment of the present application.

In step 203, the service code is associated with the corresponding service party, so that the workbench of the service party can be customized. Specifically, the service code may be integrated in a service flow of a workbench where a service provider is located, so as to provide a customized service to a user by running the service code.

After the service code is integrated in the service flow of the corresponding service party, the operation of the service code may be triggered according to a trigger request of the user in the service flow or a preset event in the service flow.

Taking the service flow as the customer service flow as an example, after a user opens the customer service work, the user triggers a loading request of the page, and the loading request can trigger the operation of the service code corresponding to the page. The plug-in is a part of the page, and the loading request of the page can also trigger the running of the service code corresponding to the plug-in. And triggering the operation of the service code corresponding to the callback object under the condition that a preset event occurs. Or, a service entry is provided in the page, a trigger request of the service entry may trigger execution of the corresponding service code.

The embodiment of the application can provide the following technical scheme for associating the service code with the corresponding service party:

the technical scheme 1,

In technical scheme 1, associating the service code with a corresponding service party specifically includes: and associating the service code and the information corresponding to the service object with the corresponding service party so as to call the service code in the service flow of the service party according to the information and provide the service corresponding to the service object for the user.

The information may be feature information of the service object, and may be an extension of the service code, which collectively serves as implementation information of the service object. For example, a service object includes a plug-in; the information specifically includes: and the plug-in identification and the page information corresponding to the plug-in. The plug-in identification may be a plug-in name. The page information corresponding to the plug-in may include: page information to which the plug-in belongs and position information of the plug-in the page to which the plug-in belongs.

The embodiment of the application can combine the service code with different information through the processing logic of the service code packaging plug-in, and can obtain the plug-ins with different plug-in attributes.

In practical application, an input interface may be provided to collect information corresponding to the service object input by the service party through the input interface.

Of course, the service code and the information are used together as implementation information of the service object, which is only an optional embodiment, and actually, a person skilled in the art may carry a plug-in attribute corresponding to the information in the service code according to an actual application requirement, for example, may carry a plug-in attribute such as a plug-in name and page information in the service code.

Technical scheme 2,

In technical solution 2, associating the service code with the corresponding service party specifically includes: issuing the micro application corresponding to the service code; and associating the micro application with a corresponding service party according to the selection request of the service party for the micro application so as to call a service code corresponding to the micro application in the service flow of the service party.

The embodiment of the application can process the service object in a micro-application mode.

Micro-applications fall into the category of micro-services. Microservice is an emerging software architecture that splits a large single application or service into tens of microservices. For example, micro-services may be separated into several micro-services according to their service attributes, or application lightweight, or loosely coupled, or independent, or voluminous, etc., which may be independent processing logic. The service object of the embodiment of the application can be one of micro services.

The micro application of the embodiment of the application can be used for realizing the processing logic corresponding to the service object. The embodiment of the application can process the service object in a micro-application mode.

The processing of the service object may specifically include: the method comprises the steps of creating the micro application, developing the micro application, associating the micro application with a service flow of the main application, running the micro application and the like.

The developer can concentrate on writing the service code, and can not pay attention to information such as running information of the service code, so that customization efficiency of the service object can be improved. The operation information may include: operation mode and operation stability, etc.

The method and the device for creating the micro application can respond to a creating request for the micro application, provide a development tool of the service object, and determine the service code matched with the development tool.

After the service code is determined, the micro application corresponding to the service code can be issued for the selection of a service party; and associating the micro application with a corresponding service party according to a selection request of the service party for the micro application so as to call a service code corresponding to the micro application in a service flow of the service party.

Technical scheme 3,

In technical scheme 3, associating the service code with the corresponding service party specifically includes: providing a plurality of service codes corresponding to the service codes; and associating the service code corresponding to the service option selected by the service party with the corresponding service party so as to provide corresponding service for the user according to the service request.

The method and the device for providing the service code can provide various service options corresponding to the service code for the service party to select, and if the service party selects one target service option, the service code corresponding to the target service option can be associated with the corresponding service party. Optionally, corresponding service options may be provided for the plurality of service directories, respectively, for selection.

Technical scheme 4,

In technical scheme 4, associating the service code with the corresponding service party specifically includes: and recording the service party information corresponding to the service code and the access address information of the service provided by the service code.

The service code provides access address information for the service that can be used to locate a specific service code in the service flow.

The method and the device for providing the service code can store the first mapping relation between the information of the service party and the access address information of the service provided by the service code, and the first mapping relation can be used for discovering the service in the service flow so as to trigger the running of the corresponding service code.

In an optional embodiment of the present application, the method may further include: and after the service code is associated with the corresponding service party, setting the state of the service object corresponding to the service code in the service party as an enabled state. The enabled state may characterize that the service object is available to the service party.

In the embodiment of the application, the service object in the non-enabled state is invisible to the user. For example, if the service has customized plug-in A in page A, plug-in A is not visible to the user if it is in the non-enabled state. In the case of plug-in A being in the activated state, plug-in A is visible to the user.

In another optional embodiment of the present application, the method may further include: storing the service code to a code space corresponding to the service object; and updating the code of the code space according to the updating of the service code.

The embodiment of the application can host the service code through the code space. Alternatively, the service code may be hosted by a code hosting device. It should be noted that, in the case of service code update, the embodiment of the present application may update the code stored in the code space, so as to apply the updated service code to the service flow.

In yet another optional embodiment of the present application, the method may further include: and constructing a container mirror image corresponding to the service object so as to run the service code according to the instance of the container mirror image.

The container realizes virtualization on the operating system level, can provide a running environment of container images, and has the advantages of convenience in deployment, safety in deployment, good isolation, low cost and the like.

It is to be understood that the above-mentioned operation of the service code according to the instance of the container image is only an alternative embodiment, and actually, the service code may also be operated in other manners, for example, the service code is packaged into a JAR (Java Archive) file, the JAR file is operated on a virtual machine, and the like. It can be understood that the embodiment of the present application does not impose a limitation on the specific operation manner of the service code.

In yet another optional embodiment of the present application, the method may further include: constructing a running engine corresponding to the service object; the operation engine specifically includes: a container unit and a container mirroring unit;

the container mirror image unit is used for storing a container mirror image corresponding to the service object; the container unit is used for operating the corresponding instance of the container mirror image.

The Container unit may be an Elastic Container Instance (ECI) unit, which may provide containerized Elastic computing services. The method can operate the container aiming at the packaged mirror image, and charge the service party according to the resource consumed by the actual operation of the container.

The container mirror image unit can provide basic container mirror image services, including safe application mirror image hosting capability, accurate mirror image safe scanning function, stable mirror image construction service and convenient mirror image authorization function, so that the life cycle management of the mirror image is facilitated.

In summary, according to the service object processing method in the embodiment of the present application, the provided development tool may be used to develop the service object, so as to obtain the service code matched with the development tool. The service code described above may be used to implement customized service objects. The service code is associated with the corresponding service party, and a customized workbench can be provided for the service party. Because the workbench of the server side comprises the customized service object, the customization requirement of the service object can be realized, and the expansion of the service capability can be further realized.

Method embodiment two

Referring to fig. 4, a schematic diagram of processing a service object based on a micro application according to the present application is shown, where a service provider, a processing platform, and an independent software developer may perform micro application processing based on data interaction.

The processing platform can create the micro application according to the creation request of the service party. Before creating the application, a project space may be created, which may include: a code space for storing service code and a mirror space for storing a container mirror. After the project space is created, the micro-application may be created.

In FIG. 4, a service may authorize a project space such that an authorized party creates and develops a micro-application under the corresponding project space. For example, the authorized party may be an independent software developer. The micro-applications developed by independent software developers can be used by one or more service parties to provide reusable application capabilities. Of course, the service side can develop the micro application by itself.

In the embodiment of the application, the server side can add cloud resources. The added cloud resources may be cloud resources owned by the server on the network. For example, the service party may obtain the cloud resource by means of renting, and the like, wherein the renting may pay a corresponding fee.

The cloud resources described above may be used to run servlets' micro-applications. For example, the cloud resources may include: at least one of a gateway unit, a load balancing unit, a proprietary network unit, a container unit, and a container mirroring unit.

According to the method and the system, the server side can be authorized to use the corresponding cloud resources, so that the server side can know the consumption information of the micro applications on the cloud resources, and the server side can manage the running state of the micro applications and the corresponding cloud resources conveniently.

In this embodiment of the present application, the publishing of the micro application may include: pre-release or online release (official release). After publishing the micro-application, a container image corresponding to the micro-application may be constructed and associated with the service flow of the corresponding service party.

The processing platform of the embodiment of the application can shield the operation details of code hosting and container mirroring according to the principle of being simple and transparent to development, and helps developers to improve development efficiency.

Referring to fig. 5, which shows an illustration of a processing procedure of a micro application according to an embodiment of the present application, a service side may create a project space on a micro application platform and bind a container mirroring service. The container mirror service can provide services such as storage, pulling and management of the mirror. The container mirroring service may create namespaces for one or more mirror repositories, and 1 or more mirror repositories may be provided under each namespace. In other words, 1 mirror instance may correspond to n namespaces, 1 namespace may correspond to n mirror repositories, and 1 mirror repository may correspond to n mirror versions.

The item space may include: a namespace, and a code set. N project spaces can be created under the processing platform. One project space may correspond to n micro applications, and n may be a natural number greater than 0.

After a micro-application is created under the project space, a corresponding code project and mirror repository may be created for the micro-application. The code item is used for storing the service code, and the mirror repository is used for storing the mirror instance corresponding to the service code.

After the creation of the micro applications is successful, micro application versions can be created, and the number of the micro application versions can be n, in other words, 1 micro application can correspond to n micro application versions. The micro application version corresponds to a branch under the code project, and a mirror image version is constructed and pushed to a mirror image warehouse when the micro application is deployed; after the micro application is successfully issued, the branch of the project instance is merged to the main branch of the project, the original branch is deleted, and the service code of the main branch is used for providing the service. 1 code group corresponds to n code groups, 1 code group corresponds to n code items, and 1 code item corresponds to a branching capability.

After the micro application is released, the embodiment of the application can determine the service corresponding to the micro application and provide the service in a service list mode. The service broker may provide a specific implementation of the service. The service agents may be used to decouple external dependencies of the service workbench, if short message facilities, robot facilities, member centers of external systems, commodity centers, order centers, etc.

Referring to fig. 6, a schematic diagram of a processing flow of a service according to an embodiment of the present application is shown, where the flow may specifically include:

step 1, a service developer develops a service corresponding to a workbench in a micro-application mode, a service agent integrates the service, and an interface of the service agent is issued through a gateway.

The service developer can be a service party and can be an independent software developer. For example, the service directory includes: service 1, service 2, … service m (m may be a natural number greater than 1), etc.

And 2, the service agent establishes a binding relationship between the service and the service party by adopting a registration mode.

For example, a service provider may be bound to a service developed by an independent software developer. Alternatively, service B may be bound to the service developed by service A.

And 3, in the process that the service user uses the workbench of the service party, the workbench of the service party sends a service request to use the bound service.

And 4, routing the service request according to the binding relation, and forwarding the service request to a corresponding service agent so that the service agent provides service.

Referring to fig. 7, a schematic structural diagram of a processing system for a service object according to an embodiment of the present application is shown, which may specifically include: the system comprises a service side, a processing platform, an initiation side and a user side.

Wherein the service party can create the micro application to the processing platform to create the micro application at the processing platform.

The processing platform may provide a development stack for development and execution of the micro-applications. The development stack may include: the distributed service framework can provide a development environment and a running environment for the micro application.

The development end can provide the service code of the micro application, submit the service code to the processing platform and trigger the release of the micro application.

The functionality of the processing platform may comprise at least one of the following: project space management, application management, version management, cloud resource management, code template management, container health management, application log management, authentication management, association of applications with service flows, code hosting, image management, and the like.

Wherein project space management can be used to manage project spaces. A project space corresponding to the service party may be created under the processing platform, and the project space may include: a namespace, and a code set. N project spaces can be created under the processing platform. One project space may correspond to n micro-applications.

Application management may be used to manage micro-applications.

Version management may be used to manage versions of micro applications. The version may be updated upon an update of the corresponding service code.

The cloud resource management may be configured to associate the cloud resources corresponding to the service provider with the micro applications, so as to run the micro applications using the cloud resources corresponding to the service provider. According to the method and the device, the cloud resource information consumed by running of the micro application can be recorded so as to be checked by a server.

The code template management can be used for providing a code template corresponding to the micro application, the code template can be used for developing the micro application, the code template can play a role in the standard of the service code, and the determination efficiency of the service code can be improved.

Container health management may be used to health monitor the corresponding instance of the container image. The health monitoring may include: resource monitoring and/or availability monitoring to improve the health of the running container of the micro-application, which in turn may improve the stability of the running of the micro-application.

In an alternative embodiment of the present application, the monitoring module and the execution module may be provided in the container unit by means of a companion container. The monitoring module may periodically (e.g., every minute) determine resource information for the container corresponding to the instance and check whether the application is available, and synchronize the monitoring results to the execution module, which takes the next action.

Referring to fig. 8, a schematic diagram of a health monitoring process according to an embodiment of the present application is shown, where a monitoring module may be disposed in a health management unit, such as Pod, and the monitoring module may perform health monitoring on a mirror instance in the health management unit and send a monitoring result to an execution module.

The monitoring module may perform health monitoring on the mirror instances in the health management unit, and specifically includes:

A) and (5) monitoring resources.

The monitoring module can periodically inquire resource information such as CPU utilization rate, memory utilization rate, load and the like of the mirror image example and send the collected resource information to the execution module. The execution module may determine whether to perform capacity reduction or capacity expansion of the mirror image instance according to a set threshold and the resource information.

If the capacity needs to be expanded, the capacity expansion action of the container can be executed, and the capacity expansion proportion can be obtained according to the algorithm or the configuration. If the capacity needs to be reduced, the container deleting action can be executed, and the capacity reduction ratio can be obtained according to an algorithm or configuration.

B) And monitoring the availability.

The monitoring module can detect whether a container corresponding to the mirror image instance opens a preset port, if the preset port is opened, the mirror image instance is considered to be in operation, otherwise, the mirror image instance can be considered to be abnormal. The preset port may be a port corresponding to the communication protocol in the embodiment of the present application. For example, if the communication Protocol is a HyperText transfer Protocol (HTTP), the preset port may be an 80 port, and it can be understood that the specific preset port is not limited in this embodiment of the application.

In the event of an exception to the mirror instance, the execution module may send a restart instruction to restart the container. If the mirror image instance is abnormal after the application is restarted, the execution module may delete the corresponding container and run the corresponding mirror image instance by using the container obtained by capacity expansion.

Application log management may be used to record events or information that occur during the execution of the micro-application.

The association of the application with the service flow can be used to determine a target service party that selects or subscribes to the micro application, and maintain a correspondence between the micro application and the service flow of the target service party.

The authentication management can be used for authenticating the service party according to the corresponding relation so as to determine the target service party which selects or subscribes the micro application, and applying the micro application in the service flow of the target service party.

And code hosting, wherein the service code can be hosted by the code hosting device.

And the mirror management can provide the safety management and the life cycle management of the mirror.

In the embodiment of the present application, the types of the micro applications may include: at least one of a page, a plug-in view, a service directory, and a callback.

Referring to fig. 9, a schematic diagram of a processing flow of a page-type micro application according to an embodiment of the present application is shown, where a page of a page type may be created by using the processing flow of the micro application, and whether the page includes a plug-in area is determined, if yes, the plug-in area is created in the page, and a cache is refreshed after the page is saved. The processing flow of the micro application may include: creation of micro applications, development of micro applications, release of micro applications, and the like.

It should be noted that, after the page is created, the state of the page at the corresponding service side may be a non-enabled state, in which case it may not be visible to the user. After associating the page with the service flow of the corresponding service party, the state of the page at the corresponding service party may be an enabled state.

Referring to fig. 10, a schematic diagram of a processing flow of a micro application of a plug-in type according to an embodiment of the present application is shown, where a plug-in of a plug-in type can be created by using the processing flow of the micro application, the plug-in is published, a subscription request of a server for the plug-in is received, a state of the plug-in a corresponding server is set to an enabled state according to the subscription request, and the plug-in and the corresponding state thereof are saved.

For the micro applications of the plug-in view, the service directory and the callback type, the processing flow is similar to that of the micro applications of the page type or the plug-in type, so that the details are not repeated herein, and the reference is only needed.

In summary, the service object processing method according to the embodiment of the present application supports customization of service objects (pages, plug-ins, plug-in views, service directories, callbacks, and the like), and opens a development tool, so that a development end can concentrate on writing of service codes without paying attention to operation information such as an operation mode and operation stability of the service objects, and thus customization efficiency of the service objects can be improved.

The embodiment of the application can meet the requirement that a service party customizes the service object by self, or can meet the requirement of the service object which can be copied in the ISV customization field.

The service object provided by the technical scheme of the embodiment of the application can be not limited by a platform, can be applied to any platform, and can be reused across platforms.

In addition, the service code can be associated with the cloud resource of the service party, so that the service code of the service party runs in the cloud resource environment of the service party, and the safety and the standardability of code running can be improved.

Method embodiment three

Referring to fig. 11, a flowchart illustrating a third step of an embodiment of a method for processing a service object according to the present application is shown, where the method may specifically include the following steps:

step 1101, receiving a use request aiming at a service object corresponding to a workbench; the service code of the service object can be associated with a corresponding service party;

step 1102, invoking a service code of the service object according to the use request.

The method of the embodiment of the application can be used for executing the service code of the service object in the service process of the service party so as to provide the service corresponding to the customized service object on the basis of the service process. At least one step included in the method of the embodiments of the present application may be performed by a processing platform. It is to be understood that the embodiments of the present application are not limited to the particular implementation of the methods.

In step 1101, the usage request may be triggered according to a triggering request of a user in a service flow or a preset event in the service flow.

Taking the service flow as the customer service flow as an example, after the customer service work is opened, the user triggers a loading request of the page, and the loading request can trigger the use request. The plug-in is a part of the page, and the loading request of the page can trigger the use request. And under the condition that a preset event occurs, triggering a use request corresponding to the callback object. Or, a service entry is provided in the page, a trigger request of the service entry may trigger a use request corresponding to the service directory.

In step 1102, a service code of the service object may be called and executed according to the usage request, so as to provide a service corresponding to the service object to a user.

In an optional embodiment of the present application, the invoking the service code of the service object specifically includes: determining a container mirror image corresponding to the service code of the service object; running the corresponding instance of the container mirror.

Optionally, the method may further include: health monitoring is performed on the corresponding instance of the container image.

The health monitoring may monitor resource information corresponding to the instance to determine whether to perform capacity reduction or capacity expansion of the mirror instance according to a set threshold and the resource information. Therefore, the utilization rate of the instance can be improved according to the real-time resource information.

Alternatively, the health monitoring may monitor the availability of the instance, so as to repair or replace the instance when the instance is unavailable, thereby improving the stability of the operation of the service code.

In another optional embodiment of the present application, the invoking the service code of the service object specifically includes: load balancing of container units is carried out on the use requests to obtain target container units corresponding to the use requests; and running the instance of the container mirror image corresponding to the service code of the service object by using the target container unit. The embodiment of the application can distribute the use request to the plurality of container units to be executed based on the load balancing technology, and the balance of the load of the plurality of container units can be controlled, so that the stability of the operation of the service code can be improved.

In yet another alternative embodiment of the present application, the method is applied to an execution engine, and the execution engine is configured to execute the service code. The cloud resources used by the running engine specifically include: and cloud resources corresponding to the service party.

The cloud resources can be used for running service codes corresponding to the service objects of the service side. For example, the cloud resources may include: at least one of a gateway unit, a load balancing unit, a proprietary network unit, a container unit, and a container mirroring unit.

According to an embodiment, the running engine specifically includes: a container unit and a container mirroring unit;

the container mirror image unit is used for storing a container mirror image corresponding to the service object; the container unit is used for running the corresponding example of the container mirror image.

According to another embodiment, the operation engine may further include: a gateway unit for receiving a request for use of the service object.

According to yet another embodiment, the operation engine may further include: and the special network unit is used for providing a network environment for the container unit and the container mirror image unit.

Referring to fig. 12, a schematic structural diagram of an operation engine according to an embodiment of the present application is shown, where the operation engine specifically includes: gateway unit, special network unit, load balancing unit, container unit and container mirror unit.

The gateway unit provides an access address for the outside and supports an authentication mechanism so as to authenticate a service party. The supported authentication mechanisms may include: OpenId (an open digital identity management and authentication framework) connection, application authentication, or the like. The gateway unit provides a public network domain name address by default and also supports the user to bind the own domain name.

The proprietary network element may be a VPC (Virtual Private Cloud) network. The method can construct a local area network for running the micro-application through the VPC, and is used for connecting the load balancing unit, the container unit and the container mirroring unit.

The load balancing unit may reverse proxy the usage request to the mounted container unit.

The container unit supports deployment of a container image corresponding to the usage request on the container unit.

After associating the service code with the service flow, the container image corresponding to the service code may be stored in the container image unit. The loading mode of the container mirror image can be as follows: and the container unit reads the container mirror image from the container mirror image unit according to the access address of the container mirror image unit.

In summary, according to the service object processing method in the embodiment of the present application, the provided development tool may be used to develop the service object, so as to obtain the service code matched with the development tool. The service code described above may be used to implement customized service objects. The service code is associated with the corresponding service party, and the service code can be integrated in the service flow of the corresponding service party, so that customized service is provided for the user by running the service code. Therefore, the expansion of the service flow can be realized, and the customization of the service object can be realized in the service flow, so that the customization requirement of the service object can be realized, and the expansion of the service capability can be realized.

Method example four

Referring to fig. 13, a flowchart illustrating a fourth step of an embodiment of a method for processing a service object according to the present application is shown, where the method may specifically include the following steps:

step 1301, providing a development tool of a page corresponding to the workbench;

step 1302, determining a service code matched with the development tool;

and 1303, associating the service code with a corresponding service party to customize a workbench of the service party.

According to the method and the device, a development tool can be provided for development aiming at the page, so that the service code matched with the development tool can be obtained; and the service code can be associated with a corresponding service party, so that the service code is called in the service flow of the service party, and the customization of the page in the workbench is realized.

The page may include: page elements, and/or a layout of page elements. The page elements may include: text, images, components, etc.

Different servers may customize different pages. For example, server A may customize image A in a first location (e.g., a business icon for server A) and server B may customize image B in a second location (e.g., a business icon for server B). The first and second locations may correspond to the same or different locations.

Method example five

Referring to fig. 14, a flowchart illustrating a fifth step of a processing method of a service object according to an embodiment of the present application is shown, where the method may specifically include the following steps:

1401, providing a development tool of a service directory corresponding to a workbench;

step 1402, determining a service code matched with the development tool;

and 1403, associating the service code with a corresponding service party so as to customize the workbench of the service party.

According to the embodiment of the application, a development tool can be provided for development aiming at the service directory, so that a service code matched with the development tool can be obtained; and, the service code may be associated with a corresponding service provider, so as to call the service code in a service flow of the service provider, thereby implementing customization of a service corresponding to a service directory.

Optionally, an interface corresponding to the service directory may also be provided. The interface corresponding to the service object may include: input parameters, output parameters and service methods, such that the service party embodies the input parameters, the output parameters and the service methods. For example, the service corresponding to the service object is a member service, the input parameter may be a member identifier such as a mobile phone number, and different service parties may use different service methods to obtain different types of member information. The different service methods may include: different member databases are accessed. The member information of different kinds may include: member ratings, historical orders for members, different information in historical postings for members, etc.

Method example six

Referring to fig. 15, a flowchart illustrating a sixth step of an embodiment of a method for processing a service object according to the present application is shown, where the method may specifically include the following steps:

step 1501, registering the service corresponding to the service code to a service directory; the service code can be obtained according to a development tool of the service object corresponding to the workbench;

step 1502, establishing a mapping relation between services in a service directory and a service party;

step 1503, receiving a service request; the service request may include: requesting a service party;

step 1504, if the service requesting party is matched with the service party in the mapping relation, calling the service code of the service corresponding to the service requesting party in the service flow of the workbench corresponding to the service requesting party.

The present embodiment may function as a service agent, which may register a service corresponding to a service code, bind the service with a service provider, and route a service request on top of the corresponding service.

Assuming that the service party a is bound with the service a and the service party B is bound with the service B, the service code of the service a may be invoked in the service flow of the service party a in the case that the requesting service party is the service party a; alternatively, in the case that the service party is the service party B, the service code of the service party B may be called in the service flow of the service party B.

Method example seven

Referring to fig. 16, a flowchart illustrating a seventh step of an embodiment of a method for processing a service object according to the present application is shown, where the method specifically includes the following steps:

step 1601, registering a service corresponding to the service code to a service directory; the service code can be obtained according to a development tool of the service object corresponding to the workbench;

step 1602, establishing a mapping relationship between services in a service directory and a service party;

step 1603, receiving a service request; the service request may include: requesting a service party;

step 1604, if the service requesting party matches the service party in the mapping relationship, determining an access address of a service code of the service corresponding to the service requesting party, so as to invoke the service code according to the access address.

The present embodiment may function as a service agent that may register a service corresponding to a service code, bind the service with a service provider, and route a service request over an access address corresponding to the service code.

The access address may be used to point to the corresponding service code, whereby access to the service code may be achieved. Alternatively, the access address may be an HTTP address. Assuming that the service party a is bound with the service a, and the access address of the service code corresponding to the service a is the address a, in the case that the requesting service party is the service party a, the address a may be determined so as to call the service code corresponding to the address a in the service flow of the service party a.

Method example eight

Referring to fig. 17, a flowchart illustrating steps of an eighth embodiment of a method for processing a service object according to the present application is shown, where the method specifically includes the following steps:

step 1701, calling a service code in a service flow of a workbench corresponding to a service party; the service code can be obtained according to a development tool of the service object corresponding to the workbench;

step 1702, charging the service party according to the calling information of the service code.

According to the method and the device, the service party is charged according to the calling information of the service codes, and the corresponding charging result can reflect the utilization rate of the service codes and the cost benefits corresponding to the service codes. The service party can pay the fee corresponding to the charging result to the processing party corresponding to the processing platform, and the fee can be used for processing the service code so as to improve the processing efficiency and the processing quality of the service code.

According to one embodiment, the invocation information may include: the calling times can set corresponding first preset cost for one calling, and therefore the service party can be charged according to the calling times and the first preset cost.

According to another embodiment, the call information may include: the called running time can set corresponding second preset cost for unit time, so that the service party can be charged according to the running time and the second preset cost.

Method example nine

Referring to fig. 18, a flowchart illustrating a ninth step of an embodiment of a method for processing a service object according to the present application is shown, where the method specifically includes the following steps:

1801, calling a service code in a service flow of a workbench corresponding to a service party; the service code can be obtained according to a development tool of the service object corresponding to the workbench;

step 1802, charging the service party according to the resource consumed by the operation of the service code.

According to the method and the device for charging the service party, the service party is charged according to the resources consumed by the operation of the service codes, and the corresponding charging result can reflect the utilization rate of the service codes and the cost benefits corresponding to the service codes. The service party can pay the fee corresponding to the charging result to the processing party corresponding to the processing platform, and the fee can be used for processing the service code so as to improve the processing efficiency and the processing quality of the service code.

The resources consumed by the execution of the service code may include: at least one of a gateway unit, a load balancing unit, a proprietary network unit, a container unit, and a container mirroring unit.

According to an embodiment, the method and the device for charging the service side can count the resources consumed by the operation of the service codes and charge the service side according to the counting result.

According to another embodiment, the service party can obtain the cloud resources by means of renting and the like, wherein the renting mode can pay corresponding fees; therefore, the cloud resources of the service party can be deducted according to the resources consumed by the operation of the service codes. In this way, the service side can be made aware of consumption information of the service code for the cloud resource.

Method example ten

Referring to fig. 22, a flowchart illustrating ten steps of an embodiment of a method for processing a service object according to the present application is shown, where the method may specifically include the following steps:

step 2201, providing an interface of a workbench; the interface may include: at least one window; the window may include: at least one government object;

step 2202, sending a use request corresponding to a target government affair object according to a trigger operation of a user for the target government affair object so as to provide a service corresponding to the target government affair object for the user; wherein the service code may be obtained by a development tool according to the target government affair object.

The method of the embodiment of the application can be applied to a government affair service scene. Government affairs may refer to the transactional work of the management organization. The method of the embodiment of the application can be applied by a government affair unit to provide government affair services for users.

In the embodiment of the application, the workbench may be a platform for providing government affairs services. The interface that the government object can provide for a workbench of the service object may include: at least one window. A window may be a window container in which controls may be carried.

Those skilled in the art can determine the type of government object included in the window according to the actual application requirements.

Optionally, the type of the government affair object may specifically include at least one of the following types: announcements, pictures, applications, information, data, and schedules.

One skilled in the art can arrange at least one type of government affairs object in the window according to the actual application requirement. Optionally, an editing interface of the window may be provided to add, delete, and also adjust the position of the government object in the window via the editing interface. Alternatively, a second window may be provided in the first window.

Referring to fig. 23, a schematic diagram of a window according to an embodiment of the present application is shown, where the window specifically includes: bulletin 2301, window 2302 corresponding to a commonly used application, picture 2303, application 1(2304), application 2(2305), and the like. It is understood that those skilled in the art can set the required government affairs objects in the window according to the actual application requirements.

Those skilled in the art can determine the corresponding function of the government affair object according to the actual application requirement. Examples of the function corresponding to the government affair object may include: health code processing, epidemic situation processing, government affair handling, personnel handling, website service, news information and the like. It is to be understood that the embodiment of the present application does not impose a limitation on the specific function corresponding to the government affair object.

In the embodiment of the application, a development tool of the government affair object can be provided, so that the corresponding service code can be developed according to the development tool. Different government objects may be developed by the same or different developers.

The method of the embodiment of the application can be executed by a workbench, the workbench can provide an interface, receive the triggering operation of the user, and send the use request corresponding to the target government affair object according to the triggering operation. The receiver corresponding to the use request may correspond to the relevant principal of the service code for the target government affairs object, and the relevant principal may include: the aforementioned processing platform, or the server side, etc.

In the embodiment of the application, the sending of the use request corresponding to the target government affair object can be used to request to invoke the service code corresponding to the target government affair object, so as to provide the service corresponding to the target government affair object for the user.

To sum up, in the method for processing a service object according to the embodiment of the present application, a government affair object is set in a window of an interface, and a use request corresponding to the target government affair object is sent according to a trigger operation of a user for the target government affair object, so that a service corresponding to the target government affair object is provided to the user based on use of a corresponding service code.

Method example eleven

Referring to fig. 24, a flowchart illustrating an eleventh step of an embodiment of a method for processing a service object according to the present application is shown, where the method specifically includes the following steps:

step 2401, receiving a use request corresponding to a target government affair object in a workbench;

step 2402, invoking a service code corresponding to the target government affair object to provide a service corresponding to the target government affair object for the user; wherein the service code may be obtained by a development tool according to the target government affair object.

The use request can be used for requesting to call a service code corresponding to the target government affair object so as to provide the service corresponding to the target government affair object for the user.

After receiving the use request, the embodiment of the application may call the service code corresponding to the target government affair object, so as to provide the service corresponding to the target government affair object to the user.

Optionally, after the service code corresponding to the target government affair object is called, the corresponding service interface may be skipped to, and different target government affair objects may correspond to different service interfaces. For example, the target government affairs object includes: after calling the service code corresponding to the application 1, the application 2 and the like can jump to the service interface of the application 1; or, after the service code corresponding to the application 2 is called, the service interface of the application 2 may be jumped to.

It should be noted that, for simplicity of description, the method embodiments are described as a series of acts or combination of acts, but those skilled in the art will recognize that the embodiments are not limited by the order of acts described, as some steps may occur in other orders or concurrently depending on the embodiments. Further, those skilled in the art will also appreciate that the embodiments described in the specification are presently preferred and that no particular act is required of the embodiments of the application.

The embodiment of the application also provides a device for processing the service object.

Referring to fig. 19, a block diagram of a service object processing apparatus according to an embodiment of the present application is shown, and specifically, the service object processing apparatus may include the following modules:

a providing module 1901, configured to provide a development tool for the service object corresponding to the workbench;

a determining module 1902, configured to determine a service code matching with the development tool;

an associating module 1903, configured to associate the service code with a corresponding service party, so as to customize a workbench of the service party.

Alternatively, the determining module 1902 may include:

the code template providing module is used for providing a code template corresponding to the development tool;

and the code receiving module is used for receiving the service code matched with the code template.

Optionally, the associating module 1903 is specifically configured to associate the service code and the information corresponding to the service object with a corresponding service party.

Optionally, the service object may include a plug-in; the information may include: plug-in identification and page information corresponding to the plug-in.

Optionally, the associating module 1903 may include:

the release module is used for releasing the micro application corresponding to the service code;

and the first association module is used for associating the micro application with a corresponding service party according to the selection request of the service party for the micro application so as to call the service code corresponding to the micro application in the service flow of the service party.

Optionally, the associating module 1903 may include:

a service option providing module for providing a plurality of service options corresponding to the service codes;

and the second association module is used for associating the service code corresponding to the service option selected by the service party with the corresponding service party so as to provide corresponding service for the user according to the service request.

Optionally, the associating module 1903 may include:

and the recording module is used for recording the service party information corresponding to the service code and the access address information of the service provided by the service code.

Optionally, the apparatus may further include:

and the state processing module is used for setting the state of the service object corresponding to the service code in the service party to be an enabled state after the service code is associated with the corresponding service party.

Optionally, the apparatus may further include:

a storage module, configured to store the service code into a code space corresponding to the service object;

and the updating module is used for updating the code of the code space according to the updating of the service code.

Optionally, the apparatus may further include:

and the container mirror image processing module is used for constructing a container mirror image corresponding to the service object so as to run the service code according to the instance of the container mirror image.

Optionally, the apparatus may further include:

the engine construction module is used for constructing an operation engine corresponding to the service object; the operation engine may include: a container unit and a container mirroring unit;

Optionally, the service object may include at least one of the following objects:

pages, plug-ins, plug-in views, service directories, and callback objects.

Optionally, there may be a plurality of the service parties; and storing the mapping relation between the personnel attribute and the encryption and decryption modes aiming at the service party.

Referring to fig. 20, a block diagram of a service object processing apparatus according to an embodiment of the present application is shown, and may specifically include the following modules:

a request receiving module 2001, configured to receive a usage request for a service object corresponding to a workstation; the service code of the service object is associated with the corresponding service party;

the code calling module 2002 is configured to call the service code of the service object according to the use request.

Optionally, the calling module 2002 may include:

a container mirror image determining module, configured to determine a container mirror image corresponding to the service code of the service object;

and the first instance running module is used for running the instance corresponding to the container mirror image.

Optionally, the apparatus may further include:

and the charging module is used for charging the service party according to the resources consumed by the container mirror image instance.

Optionally, the apparatus may further include:

and the health monitoring module is used for carrying out health monitoring on the corresponding example of the container mirror image.

Optionally, the calling module 2002 may include:

a load balancing module, configured to perform load balancing on the container unit for the usage request to obtain a target container unit corresponding to the usage request;

and the second instance running module is used for running the instance of the container mirror image corresponding to the service code of the service object by using the target container unit.

Optionally, the apparatus is applied to an execution engine, and the cloud resources used by the execution engine may include: and cloud resources corresponding to the service party.

Optionally, the running engine may include: a container unit and a container mirroring unit;

Optionally, the running engine may further include: a gateway unit for receiving a request for use of the service object.

Optionally, the running engine may further include: and the special network unit is used for providing a network environment for the container unit and the container mirror image unit.

The embodiments in the present specification are described in a progressive manner, each embodiment focuses on differences from other embodiments, and the same and similar parts among the embodiments are referred to each other.

With regard to the apparatus in the above-described embodiment, the specific manner in which each module performs the operation has been described in detail in the embodiment related to the method, and will not be elaborated here.

Embodiments of the application can be implemented as a system or apparatus employing any suitable hardware and/or software for the desired configuration. Fig. 21 schematically illustrates an example device 2500 that can be used to implement various embodiments described herein.

For one embodiment, fig. 21 illustrates an exemplary device 2500, where the device 2500 may comprise: one or more processors 2502, a system control module (chipset) 2504 coupled to at least one of processors 2502, system Memory 2506 coupled to system control module 2504, Non-volatile Memory/storage 2508 coupled to system control module 2504, one or more input/output devices 2510 coupled to system control module 2504, and a network interface 2512 coupled to system control module 2506. The system memory 2506 may include: instructions 2562, the instructions 2562 being executable by the one or more processors 2502.

The processor 2502 may include one or more single-core or multi-core processors, and the processor 2502 may include any combination of general-purpose or special-purpose processors (e.g., graphics processors, application processors, baseband processors, etc.). In some embodiments, the device 2500 can be a server, a target device, a wireless device, etc., as described in embodiments herein.

In some embodiments, the device 2500 may include one or more machine-readable media (e.g., system memory 2506 or NVM/storage 2508) having instructions and one or more processors 2502, which in combination with the one or more machine-readable media, are configured to execute the instructions to implement the modules included in the aforementioned means to perform the actions described in embodiments of the present application.

System control module 2504 for one embodiment may comprise any suitable interface controller to provide any suitable interface to at least one of processors 2502 and/or any suitable device or component in communication with system control module 2504.

System control module 2504 for one embodiment may comprise one or more memory controllers to provide an interface to system memory 2506. The memory controller may be a hardware module, a software module, and/or a firmware module.

System memory 2506 for one embodiment may be used to load and store data and/or instructions 2562. For one embodiment, system Memory 2506 may comprise any suitable volatile Memory, such as suitable DRAM (Dynamic Random Access Memory). In some embodiments, system memory 2506 may include: double data rate type quad synchronous dynamic random access memory (DDR4 SDRAM).

System control module 2504 for one embodiment may include one or more input/output controllers to provide an interface to NVM/storage 2508 and input/output device(s) 2510.

NVM/storage 2508 for one embodiment may be used to store data and/or instructions 2582. NVM/storage 2508 may include any suitable non-volatile memory (e.g., flash memory, etc.) and/or may include any suitable non-volatile storage device(s), such as one or more Hard Disk Drive (HDD (s)), one or more Compact Disc (CD) Drive(s), and/or one or more Digital Versatile Disc (DVD) Drive(s), etc.

NVM/storage 2508 may include storage resources that are physically part of the device on which apparatus 2500 is installed, or it may be accessible by, and not necessarily part of, the device. For example, NVM/storage 2508 may be accessible over a network via network interface 2512 and/or through input/output devices 2510.

Input/output device(s) 2510 for one embodiment may provide an interface for device 2500 to communicate with any other suitable devices, and input/output device(s) 2510 may include communication components, audio components, sensor components, and so forth.

Network interface 2512 for one embodiment may provide an interface for device 2500 to communicate with one or more components of a Wireless network, e.g., access to a Wireless network based on a communication standard, such as WiFi (Wireless Fidelity), 2G or 3G or 4G or 5G, or a combination thereof, and/or with any other suitable means and according to any of one or more Wireless network standards and/or protocols for Wireless communication with one or more components of the Wireless network.

For one embodiment, at least one of the processors 2502 may be packaged together with logic for one or more controllers (e.g., memory controllers) of the system control module 2504. For one embodiment, at least one of the processors 2502 may be packaged together with logic for one or more controllers of the System control module 2504 to form a System In Package (SiP). For one embodiment, at least one of the processors 2502 may be integrated on the same novelty as the logic of one or more controllers of the system control module 2504. For one embodiment, at least one of the processors 2502 may be integrated on the same Chip with logic for one or more controllers of the System control module 2504 to form a System on Chip (SoC).

In various embodiments, device 2500 may include, but is not limited to: a computing device such as a desktop computing device or a mobile computing device (e.g., a laptop computing device, a handheld computing device, a tablet, a netbook, etc.). In various embodiments, device 2500 may have more or fewer components and/or different architectures. For example, in some embodiments, device 2500 may include one or more cameras, keyboards, Liquid Crystal Display (LCD) screens (including touch screen displays), non-volatile memory ports, multiple antennas, graphics chips, Application Specific Integrated Circuits (ASICs), and speakers.

Wherein, if the display includes a touch panel, the display screen may be implemented as a touch screen display to receive an input signal from a user. The touch panel includes one or more touch sensors to sense touch, slide, and gestures on the touch panel. The touch sensor may not only sense the boundary of a touch or slide action, but also detect the duration and pressure associated with the touch or slide operation.

The present application also provides a non-transitory readable storage medium, where one or more modules (programs) are stored in the storage medium, and when the one or more modules are applied to an apparatus, the apparatus may be caused to execute instructions (instructions) of methods in the present application.

Provided in one example is an apparatus comprising: one or more processors; and, instructions in one or more machine-readable media stored thereon, which when executed by the one or more processors, cause the apparatus to perform a method as in embodiments of the present application, which may include: the method shown in any one of fig. 1 to 11.

One or more machine-readable media are also provided in one example, having instructions stored thereon, which when executed by one or more processors, cause an apparatus to perform a method as in embodiments of the application, which may include: the method shown in any one of fig. 1 to 11.

The specific manner in which each module performs operations of the apparatus in the above embodiments has been described in detail in the embodiments related to the method, and will not be described in detail here, and reference may be made to part of the description of the method embodiments for relevant points.

Embodiments of the present application are described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the application. 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 service object processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable service object 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 processing device of a computer or other programmable service object 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 processing device of a computer or other programmable service object 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.

While preferred embodiments of the present application have been described, additional variations and modifications of these embodiments may occur to those skilled in the art once they learn of the basic inventive concepts. Therefore, it is intended that the appended claims be interpreted as including the preferred embodiment and all such alterations and modifications as fall within the true scope of the embodiments of the application.

Finally, it should also be noted that, herein, relational terms such as first and second, and the like may be used solely to distinguish one entity or action from another entity or action without necessarily requiring or implying any actual such relationship or order between such entities or actions. Also, 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 like elements in a process, method, article, or apparatus that comprises the element.

The foregoing detailed description is directed to a method for processing a service object, a device for processing a service object, an apparatus, and a machine-readable medium, which are provided by the present application, and specific examples are applied in the present application to explain the principles and embodiments of the present application, and the descriptions of the foregoing examples are only used to help understand the method and the core ideas of the present application; meanwhile, for a person skilled in the art, according to the idea of the present application, there may be variations in the specific embodiments and the application scope, and in summary, the content of the present specification should not be construed as a limitation to the present application.

Claims

1. A method for processing a service object, the method comprising:

determining a service code matching the development tool;

2. The method of claim 1, wherein determining the service code of the service object comprises:

providing a code template corresponding to the development tool;

and receiving the service code matched with the code template.

3. The method of claim 1, wherein associating the service code with the corresponding service party comprises:

and associating the service code and the information corresponding to the service object with the corresponding service party.

4. The method of claim 3, wherein the service object comprises a plug-in; the information includes: plug-in identification and page information corresponding to the plug-in.

5. The method of claim 1, wherein associating the service code with the corresponding service party comprises:

issuing the micro application corresponding to the service code;

and associating the micro application with a corresponding service party according to the selection request of the service party for the micro application so as to call a service code corresponding to the micro application in the service flow of the service party.

6. The method of claim 1, wherein associating the service code with the corresponding service party comprises:

providing a plurality of service options corresponding to the service codes;

and associating the service code corresponding to the service option selected by the service party with the corresponding service party so as to provide corresponding service for the user according to the service request.

7. The method of claim 1, wherein associating the service code with the corresponding service party comprises:

and recording the service party information corresponding to the service code and the access address information of the service provided by the service code.

8. The method of claim 1, further comprising:

and after the service code is associated with the corresponding service party, setting the state of the service object corresponding to the service code in the service party as an enabled state.

9. The method of claim 1, further comprising:

storing the service code to a code space corresponding to the service object;

and updating the code of the code space according to the updating of the service code.

10. The method of claim 1, further comprising:

and constructing a container mirror image corresponding to the service object so as to run the service code according to the instance of the container mirror image.

11. The method of claim 1, further comprising:

constructing a running engine corresponding to the service object; the execution engine includes: a container unit and a container mirroring unit;

12. The method according to any of claims 1 to 11, wherein the service object comprises at least one of the following objects:

pages, plug-ins, plug-in views, service directories, and callback objects.

13. The method according to any one of claims 1 to 11, wherein the service side is plural; and storing the mapping relation between the personnel attribute and the encryption and decryption modes aiming at the service party.

14. A method for processing a service object, the method comprising:

15. The method of claim 14, wherein said invoking service code of said service object comprises:

determining a container mirror image corresponding to the service code of the service object;

and running the corresponding instance of the container mirror.

16. The method of claim 15, further comprising:

and charging the service party according to the resources consumed by the container mirror image instance.

17. The method of claim 15, further comprising:

health monitoring is performed on the corresponding instance of the container image.

18. The method of claim 14, wherein said invoking service code of said service object comprises:

load balancing of container units is carried out on the use requests, so that target container units corresponding to the use requests are obtained;

and running the instance of the container mirror image corresponding to the service code of the service object by using the target container unit.

19. The method of claim 14, applied to a runtime engine that uses cloud resources comprising: and cloud resources corresponding to the service party.

20. The method of claim 19, wherein the runtime engine comprises: a container unit and a container mirroring unit;

21. The method of claim 19, wherein the runtime engine further comprises: a gateway unit for receiving a request for use of the service object.

22. The method of claim 19, wherein the runtime engine further comprises: and the special network unit is used for providing a network environment for the container unit and the container mirror image unit.

23. A method for processing a service object, the method comprising:

providing a development tool of a page corresponding to the workbench;

determining a service code matching the development tool;

24. A method for processing a service object, the method comprising:

determining a service code matching the development tool;

25. A method for processing a service object, the method comprising:

26. A method for processing a service object, the method comprising:

27. A method for processing a service object, the method comprising:

28. A method for processing a service object, the method comprising:

29. An apparatus for processing a service object, the apparatus comprising:

30. An apparatus for processing a service object, the apparatus comprising:

31. An apparatus, comprising:

one or more processors; and

one or more machine-readable media having instructions stored thereon that, when executed by the one or more processors, cause the apparatus to perform the method of one or more of claims 1-13.

32. One or more machine-readable media having instructions stored thereon, which when executed by one or more processors, cause an apparatus to perform the method recited by one or more of claims 1-13.

33. A method for processing a service object, comprising:

34. The method according to claim 32, wherein the type of the government object comprises at least one of the following types:

announcements, pictures, applications, information, data, and schedules.

35. A method for processing a service object, comprising: