CN111641675A - Multi-tenant access service implementation method, device, equipment and storage medium - Google Patents

Abstract

The invention relates to artificial intelligence, and provides a method, a device, equipment and a storage medium for realizing multi-tenant access service, wherein the method comprises the following steps: modifying the application context adapted to a set of tenant access service on the same platform into the application context adapted to a plurality of sets of independent tenant access services by modifying the underlying technology of a multi-tenant architecture, configuring a general function implementation class and a tenant customization function implementation class for each set of tenant access service, and starting a corresponding instance of each function implementation class through interface programming of the application context; in the service starting stage, loading corresponding application context for each set of tenant access service; in the service running process, the corresponding application context is obtained through the tenant certificate information of the tenant client and is accessed to the current thread, and the corresponding tenant access service is started. In addition, the invention also relates to a block chain technology, and related information can be stored in the block chain nodes.

Description

Multi-tenant access service implementation method, device, device and storage medium

technical field

The present invention relates to the technical field of artificial intelligence, and in particular, to a method, apparatus, device and storage medium for implementing a multi-tenant access service.

Background technique

Microservices, as a new technology for deploying applications and services in the cloud, has become the latest hot topic. The development of microservice technology firstly solves the problems of development, testing, deployment and maintenance of traditional large-scale software. The modification of each functional module needs to consider the overall changes of the software application, while the microservice technology divides the entire large application into multiple Independent small modules, each small module basically only needs to be responsible for its own business function development, testing, deployment, and operation and maintenance. Today, microservices are the leader in software application model innovation. From traditional on-premise deployment of software products to cloud deployments, a new delivery method has been defined, which reduces the large amount of upfront investment required for local deployment and integrates software The application returns to its essential service properties.

Today's microservices use a multi-tenant architecture. The same set of services is oriented to multiple customers and needs to meet the respective needs of multiple tenants as much as possible. For individual users, the platform only needs to meet public needs. For enterprise users, it needs to be satisfied as much as possible, but due to the various and even conflicting needs of customers, it is difficult to expand for enterprise users. Often in order to meet the needs of one tenant, the business of other tenants is affected. So how to provide multiple sets of customized services on a multi-tenant architecture to meet different user needs?

SUMMARY OF THE INVENTION

The main purpose of the present invention is to solve the problem of how to provide multiple sets of customized services on a multi-tenant architecture to meet the needs of different users.

A first aspect of the present invention provides a multi-tenant access service implementation micro-service architecture method, including:

Reading a tenant configuration file, where the tenant configuration file includes a custom function implementation class and/or a general function implementation class corresponding to each tenant access service;

Create an application context corresponding to each tenant access service based on the custom function implementation class and/or general function implementation class corresponding to each tenant access service;

receiving and parsing the access service request initiated by the tenant client to obtain tenant credential information corresponding to the tenant client;

According to the tenant credential information, obtain the corresponding tenant information and parse it to obtain the tenant identification information;

According to the tenant identification information, the application context corresponding to the access service of the tenant client is determined and allocated to the thread where the access service request is located.

Optionally, in the first implementation manner of the first aspect of the present invention, when the tenant configuration file is read, the tenant configuration file contains custom function implementation classes and/or general functions corresponding to each tenant access service. Before implementing the class step, also include:

Load the preset default application context to implement common functions for each tenant to access services;

Determine whether the interface required by the default application context corresponds to one or more general function implementation classes;

If it corresponds to a general function implementation class, the general function implementation class is used as the implementation class corresponding to the interface of the default application context;

If it corresponds to multiple general function implementation classes, select one of the preset general function implementation classes as the implementation class corresponding to the interface required by the default application context.

Optionally, in the second implementation manner of the first aspect of the present invention, the application corresponding to each tenant access service is created based on the custom function implementation class and/or the general function implementation class corresponding to each tenant access service. Context multi-tenant access service implementations include:

Parse the tenant configuration file, and obtain the custom function implementation class with the first identification information and/or the general function implementation class with the second identification information corresponding to each tenant access service;

Based on the first identification information and/or the second identification information, and the required interface of each tenant's access service corresponding to the application context, determine the application context and each custom function implementation class and/or each general function implementation class relationship between;

Based on the association relationship, the required interface is bound to the corresponding custom function implementation class and/or general function implementation class, an application context corresponding to each tenant access service is generated, and the tenant identification information of the corresponding tenant is used for identification.

Optionally, in a third implementation manner of the first aspect of the present invention, the receiving and parsing the access service request initiated by the tenant client to obtain the tenant credential information corresponding to the tenant client includes:

Intercept the access service request initiated by the tenant client;

determining the access service type of the tenant client according to the access service request;

If the access service type is a non-login access service, parse the access service request, and obtain the tenant credential information corresponding to the tenant client as a secret key;

If the access service type is a login access service, the access service request is parsed, and the tenant credential information corresponding to the tenant client is obtained as a tenant identity token.

Optionally, in the fourth implementation manner of the first aspect of the present invention, after the step of acquiring and parsing the corresponding tenant information according to the tenant credential information to obtain the tenant identification information, the method further includes:

If the tenant credential information is a tenant identity token, create a session object corresponding to the tenant client based on the tenant identity token;

generating the session identification information corresponding to the session object and sending it to the tenant client for saving;

The tenant information is saved to the session object, and a corresponding implementation class is called according to the tenant information stored in the session object.

Optionally, in the fifth implementation manner of the first aspect of the present invention, according to the tenant identification information, the application context corresponding to the access service of the tenant client is determined and allocated to the thread where the access service request is located. After the steps, also include:

receiving a service processing request with the session identification information and the first identification information or the second identification information initiated when the tenant client invokes the customization function;

determining, according to the session identification information, a session object corresponding to the tenant client;

According to the first identification information or the second identification information, a corresponding function implementation class in the tenant information stored in the session object is determined, and an application context interface corresponding to client business processing is instantiated through the function implementation class.

A second aspect of the present invention provides a device for implementing a multi-tenant access service, including:

a receiving module, configured to read a tenant configuration file, where the tenant configuration file includes a custom function implementation class and/or a general function implementation class corresponding to each tenant access service;

A creation module, configured to create an application context corresponding to each tenant access service based on the custom function implementation class and/or general function implementation class corresponding to each tenant access service;

a parsing module, configured to receive and parse an access service request initiated by a tenant client to obtain tenant credential information corresponding to the tenant client; acquire and parse corresponding tenant information according to the tenant credential information to obtain tenant identification information;

The allocation module is configured to determine, according to the tenant identification information, an application context corresponding to the access service of the tenant client and allocate it to the thread where the access service request is located.

Optionally, in the first implementation manner of the second aspect of the present invention, a startup module is also included, which is specifically used for:

Load the preset default application context to implement common functions for each tenant to access services;

Determine whether the interface required by the default application context corresponds to one or more general function implementation classes;

If it corresponds to a general function implementation class, the general function implementation class is used as the implementation class corresponding to the interface of the default application context;

If it corresponds to multiple general function implementation classes, select one of the preset general function implementation classes as the implementation class corresponding to the interface required by the default application context.

Optionally, in a second implementation manner of the second aspect of the present invention, the creation module further includes:

a first parsing unit, configured to parse a tenant configuration file, and obtain a custom function implementation class with first identification information and/or a general function implementation class with second identification information corresponding to each tenant access service;

The screening unit is configured to determine, based on the first identification information and/or the second identification information, and the required interface of the application context corresponding to each tenant access service, the application context and each custom function implementation class and/or each Association between generic function implementation classes;

A matching unit, configured to bind the required interface with the corresponding custom function implementation class and/or general function implementation class based on the association relationship, generate an application context corresponding to each tenant access service, and use the tenant of the corresponding tenant identification information for identification.

Optionally, in a third implementation manner of the second aspect of the present invention, the parsing module is specifically used for:

Intercept the access service request initiated by the tenant client;

determining the access service type of the tenant client according to the access service request;

If the access service type is a non-login access service, parse the access service request, and obtain the tenant credential information corresponding to the tenant client as a secret key;

If the access service type is a login access service, the access service request is parsed, and the tenant credential information corresponding to the tenant client is obtained as a tenant identity token.

Optionally, in a fourth implementation manner of the second aspect of the present invention, the device for implementing multi-tenant access services further includes a recording module for:

If the tenant credential information is a tenant identity token, create a session object corresponding to the tenant client based on the tenant identity token;

generating the session identification information corresponding to the session object and sending it to the tenant client for saving;

The tenant information is saved to the session object, and a corresponding implementation class is called according to the tenant information stored in the session object.

Optionally, in a fifth implementation manner of the second aspect of the present invention, the allocation module is further used for:

receiving a service processing request with the session identification information and the first identification information or the second identification information initiated when the tenant client invokes the customization function;

determining, according to the session identification information, a session object corresponding to the tenant client;

According to the first identification information or the second identification information, a corresponding function implementation class in the tenant information stored in the session object is determined, and an application context interface corresponding to client business processing is instantiated through the function implementation class.

A third aspect of the present invention provides a device for implementing multi-tenant access services, comprising: a memory and at least one processor, wherein the memory stores instructions, and the memory and the at least one processor are interconnected through a line; the At least one processor invokes the instructions in the memory, so that the multi-tenant access service implementation device executes the above-mentioned multi-tenant access service implementation method.

A fourth aspect of the present invention provides a computer-readable storage medium, comprising a storage data area and a storage program area, the storage data area stores data created according to the use of blockchain nodes, and the storage program area stores a computer program, wherein , the computer program is executed by the processor to implement the above multi-tenant access service implementation method.

In the technical solution provided by the present invention, a tenant configuration file is read, and the tenant configuration file contains custom function implementation classes and/or general function implementation classes corresponding to each tenant access service; based on the customization corresponding to each tenant access service A function implementation class and/or a general function implementation class, to create an application context corresponding to each tenant's access service; receive and parse the access service request initiated by the tenant client to obtain the tenant credential information corresponding to the tenant client; according to the tenant For the credential information, the corresponding tenant information is obtained and analyzed to obtain the tenant identification information; according to the tenant identification information, the application context corresponding to the access service of the tenant client is determined and allocated to the thread where the access service request is located. In the embodiment of the present invention, the beneficial effect of providing multiple sets of customized services on a multi-tenant architecture is obtained.

Description of drawings

FIG. 1 is a schematic diagram of an embodiment of a method for implementing a multi-tenant access service in an embodiment of the present invention;

FIG. 2 is a schematic diagram of another embodiment of a method for implementing a multi-tenant access service in an embodiment of the present invention;

3 is a schematic diagram of an embodiment of an apparatus for implementing a multi-tenant access service in an embodiment of the present invention;

4 is a schematic diagram of another embodiment of an apparatus for implementing a multi-tenant access service in an embodiment of the present invention;

FIG. 5 is a schematic diagram of an embodiment of a device for implementing a multi-tenant access service in an embodiment of the present invention.

Detailed ways

The embodiments of the present invention provide a multi-tenant access service implementation method, device, device and storage medium. By modifying the underlying technology of the multi-tenant architecture, the application context for adapting a set of tenant access services on the same platform is modified to adapt Multiple sets of independent tenants access the application context of the service, and configure common function implementation classes and tenant-customized function implementation classes for each set of tenant access services, and start the corresponding instance of each function implementation class through the interface programming of the application context; in the service startup phase , first load the corresponding application context for each set of tenant access services; during the service operation process, obtain the corresponding application context through the tenant credential information of the tenant client and access the current thread, start the corresponding tenant access service, and obtain the multi-tenant optimization through optimization. The beneficial effect of the architecture meeting the different needs of multiple users.

The terms "first", "second", "third", "fourth", etc. (if present) in the description and claims of the present invention and the above-mentioned drawings are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence. It is to be understood that data so used may be interchanged under appropriate circumstances so that the embodiments described herein can be practiced in sequences other than those illustrated or described herein. Furthermore, the terms "comprising" or "having" and any variations thereof are intended to cover non-exclusive inclusion, for example, a process, method, system, product or device comprising a series of steps or units is not necessarily limited to those expressly listed steps or units, but may include other steps or units not expressly listed or inherent to these processes, methods, products or devices.

For ease of understanding, the following describes the specific process of the embodiment of the present invention. Referring to FIG. 1 , an embodiment of a method for implementing a multi-tenant access service in the embodiment of the present invention includes:

101. Read a tenant configuration file, where the tenant configuration file includes a custom function implementation class and/or a general function implementation class corresponding to each tenant access service;

It can be understood that the executive body of the present invention may be an apparatus for implementing multi-tenant access services, and may also be a terminal or a server, which is not specifically limited here. The embodiments of the present invention are described by taking a server as an execution subject as an example.

In this embodiment, the specific implementation of the method of the present invention is explained through the spring framework. During the development of this system, an external configuration file has been created and the tenant information table and function implementation class are stored; when the tenant access service is started, the corresponding custom function implementation class and/or the corresponding tenant access service described in the tenant information table Generic function implementation class to start an instance.

For example, tenant access service A includes Comonbean1, Comonbean2, Comonbean3, and Comonbean4; tenant access service B includes Comonbean1, Comonbean3, bean110, and bean121, where Comonbean is a general function implementation class, and bean is a custom function implementation class.

102. Create an application context corresponding to each tenant access service based on the custom function implementation class and/or general function implementation class corresponding to each tenant access service;

In this embodiment, spring belongs to a container framework. Here, we modify the application context container of the underlying technology of spring, and modify the original platform to have only one set of application contexts so that each tenant access service has its own application context. First, modify the application context environment adapted to one set of tenant access services to the application context environment adapted to multiple sets of tenant access services. The platform server obtains the custom function implementation class and/or general function implementation class for each tenant access service. Then, based on the different needs of each tenant to access the service, mark the corresponding interface programming, each custom function implementation class mark itself can implement the interface and the tenant to which it belongs, and each general function implementation class mark itself can implement the interface, and each of the tenants accessing the service is marked. A marker interface is associated with a corresponding function implementation class to generate an application context corresponding to each tenant's access service.

For example, tenant access service A marks interface 1, interface 2, interface 3, interface 1 in interface, interface 3, interface 4, Comonbean1 tag implements interface 1, Comonbean2 tag implements interface 2, bean tag implements interface 3 and If it belongs to tenant A and bean4 marks implementation interface 4 and belongs to tenant A, in the application context of tenant access A, associate Comonbean1 with interface 1, bean113 and interface 3, bean114 and interface 4, and obtain the exclusive application context of tenant access service A .

103. Receive and parse the access service request initiated by the tenant client to obtain tenant credential information corresponding to the tenant client;

In this embodiment, when a tenant client accesses the virtual application platform built by the spring framework, it needs to initiate an access service request to the platform server to enter the corresponding application interface, and the header of the access service request carries the tenant credential information of the tenant client , which is used by the platform server to verify the identity of the tenant client.

One type of tenant credential information is a tenant identity token, an example of which is: field A. field B. field C. Among them, the most important information of the tenant identity token is the load field "field B" between two ".", which represents the tenant client ID of the tenant identity token, and the creation time and the time used to help retrieve the tenant client. Expiration time, indicating the identity and validity of the tenant identity token.

104. Obtain and parse corresponding tenant information according to the tenant credential information to obtain tenant identification information;

In this embodiment, each tenant access service stores a copy of the configured tenant information, which is marked with the tenant identification information. When the user selects the desired tenant access service, the user's tenant client ID is bound to the tenant identification information of the tenant information corresponding to the tenant access service. Using the tenant client ID in the tenant identification information obtained in the previous step, retrieve the corresponding tenant identification information, and obtain the tenant information corresponding to the tenant identification information, so that the platform server can invoke the required tenant access service for the tenant client, and It can be used by the subsequent platform server to call the corresponding function implementation class for the required custom service of the tenant client.

For example, when the tenant credential information is a tenant security token, it includes the signed "field B", and after decoding, the tenant client ID in the payload field is obtained. If the tenant client ID is bound to the tenant identification information I of the tenant information T, Then, the tenant identification information I is retrieved and the corresponding tenant information T is obtained.

105. Determine, according to the tenant identification information, an application context corresponding to the access service of the tenant client and assign it to the thread where the access service request is located.

In this embodiment, the application context corresponding to each tenant access service is also marked with the tenant identification information, and the application context corresponding to the tenant access service can be found by retrieving the incoming tenant identification information; and the virtual application platform relies on the application context to realize Each tenant independently customizes the function, specifically by calling the function of the application context to realize the required interface for class instantiation. Here, the corresponding tenant access service of the tenant client can be realized by accessing the application context by accessing the thread where the service request is located.

For example, the default functions of tenant client A are function 1, function 2, and function 3; there is an application context A corresponding to tenant access service A in the thread of tenant client A, the implementation of function A requires Comonbean1 to instantiate interface 1, and the implementation of function 2 requires an instance of bean113 To implement interface 3, bean 114 needs to instantiate interface 4 to realize function 3; function 1, function 2, and function 3 can be implemented for tenant client A by assigning application context A to the thread where the access service request is located.

In the embodiment of the present invention, by modifying the underlying technology of the multi-tenant architecture, the application context adapted to one set of tenant access services on the same platform is modified to the application context adapted to multiple sets of independent tenant access services. The service configures the general function implementation class and the tenant-customized function implementation class, and starts the corresponding instance of each function implementation class through the interface programming of the application context; in the service startup phase, first load the corresponding application context for each set of tenant access services; During the running process, the corresponding application context is obtained through the tenant credential information of the tenant client, and the current thread is accessed, and the corresponding tenant access service is started, so as to obtain the beneficial effect of providing multiple sets of customized services on the multi-tenant architecture.

Referring to FIG. 2, another embodiment of a method for implementing a multi-tenant access service in an embodiment of the present invention includes:

201. Load a preset default application context for realizing the general function of each tenant accessing the service;

202. Determine that the interface required by the default application context corresponds to one or more general function implementation classes;

203. If it corresponds to a general function implementation class, use the general function implementation class as the implementation class corresponding to the interface of the default application context;

204. If it corresponds to multiple general function implementation classes, select one of the preset general function implementation classes as the implementation class corresponding to the interface required by the default application context.

In this embodiment, when the tenant access service is started, a set of general tenant access services will also be loaded to construct a default application context. For users who do not have custom function permissions, they can access their tenant access services in the same way as general functions.

In this embodiment, the association relationship between the interface required by the default application and the generic function implementation class can be determined by the programming information of the required interface and the label information of the interface to which the generic function implementation class belongs.

In this embodiment, the interface required by the default application context may correspond to multiple general function implementation classes and custom function implementation classes, because the custom function implementation class not only marks its own implementation interface, but also marks the tenant access service to which it belongs and does not include the general tenant access service, and the interface required by each application context also marks its own reference preference, so when the platform server selects multiple function implementation classes corresponding to the interface required by the default application context, it selects the preset general function implementation class through the reference preference mark .

For example, if the implementation classes corresponding to the interface A required by the default application context are: Comonbean3, Comonbean4, Comonbean5, bean3, bean4, and bean5, the platform server directly selects the three general implementation classes Comonbean3, Comonbean4, and Comonbean5 for instantiating the interface. A required generic implementation class.

In this embodiment, by loading the default application context when the tenant access service is started, it can be used for subsequent tenant clients to invoke the default application context to use the general tenant access service.

205. Read a tenant configuration file, where the tenant configuration file includes a custom function implementation class and/or a general function implementation class corresponding to each tenant access service;

206. Create an application context corresponding to each tenant access service based on the custom function implementation class and/or general function implementation class corresponding to each tenant access service;

In this embodiment, the specific creation process of the application context corresponding to each tenant access service is as follows:

Parse the tenant configuration file, and obtain the custom function implementation class with the first identification information and/or the general function implementation class with the second identification information corresponding to each tenant access service;

Based on the first identification information and/or the second identification information, and the required interface of each tenant's access service corresponding to the application context, determine the application context and each custom function implementation class and/or each general function implementation class relationship between;

Based on the association relationship, the required interface is bound to the corresponding custom function implementation class and/or general function implementation class, an application context corresponding to each tenant access service is generated, and the tenant identification information of the corresponding tenant is used for identification.

In this embodiment, the present invention can realize the creation and switching of instances in the running process through the dynamic proxy. The tenant configuration file stores the corresponding function implementation classes of each tenant's access service, and each function implementation class is identified by identification information. The first identification information corresponding to the custom function implementation class is used to identify the implemented interface and the tenant to which it belongs, and the second identification information corresponding to the general function implementation class is used to identify the implemented interface.

When invoking functions during tenant use, instances in the application context can be created and invoked through dynamic proxy. When the service is started, annotations, application context interfaces, and function implementation classes need to be defined. For example, define an annotation named AbcAnnotation, pass in ElementType.TYPE in @Target to indicate that the annotation can be used for function implementation classes and interfaces, and use @Retention(RetentionPolicy.RUNTIME) to indicate that the annotation lifetime is at runtime, the tenant service The client can call the corresponding function implementation class through the reference relationship between the function implementation class and the AbcAnnotation annotation.

In this embodiment, the platform marks the required interface of the corresponding application context based on the requirements of each tenant to access the service, and the programming of the application context interface has a corresponding relationship with the corresponding first identification information and/or second identification information, and determines the application context. A custom function implementation class corresponding to each interface and/or each general function implementation class.

In this embodiment, the function implementation class refers to the ClassAnnotation annotation, and through the function identifier of the interface to which the application context belongs, the two form an association relationship. It is bound with the function implementation class to generate the application context corresponding to the tenant access service, and is identified by the tenant identification information corresponding to the tenant access service to which it belongs.

207. Receive and analyze the access service request initiated by the tenant client to obtain tenant credential information corresponding to the tenant client;

In this embodiment, the specific implementation process of obtaining the tenant credential information by parsing the access service request is as follows:

Intercept the access service request initiated by the tenant client;

determining the access service type of the tenant client according to the access service request;

If the access service type is a non-login access service, parse the access service request, and obtain the tenant credential information corresponding to the tenant client as a secret key;

If the access service type is a login access service, the access service request is parsed, and the tenant credential information corresponding to the tenant client is obtained as a tenant identity token.

In this embodiment, when the user accesses the virtual application platform through the tenant client, the platform server intercepts the access service request initiated by the tenant client client through the request interceptor, and the request interceptor can filter the access request of the non-local virtual application platform , Verify the user's login status, and determine whether the tenant credential information in the access service request is invalid, etc.

If the access service request intercepted by the request interceptor carries the tenant identity token, according to the identity token, the session corresponding to the token is queried from the server cache, and the session validity period is obtained from the session. Within the validity period of the tenant identity token, it indicates that the tenant identity token is still valid, and the processing flow of the access service request is performed normally; if the request reception time exceeds the validity period of the tenant identity token, it indicates that the tenant identity token is valid. If the token is invalid and the request fails, execute the processing logic for the invalidation of the tenant identity token. For example, if a prompt message is sent to the tenant client to remind the user that the login has timed out, please log in again.

In this embodiment, the request interceptor is used to intercept the access service request sent by the client, obtain the current login token from the cookie of the service request, query the session (session) from the server cache according to the token, and obtain the tenant information from the session , and execute the corresponding tenant access request processing logic according to the type of the tenant identification information, where the access service type can be non-login state or login state.

In this embodiment, in the non-login tenant access service, a secret key needs to be added to the access service request for the request interceptor to verify, and the corresponding non-login tenant access request processing logic is executed. After the virtual application platform, the business processing interface cannot be entered, there is no business processing history record, and there is no calling authority for some functional modules.

In this embodiment, in the login state tenant access service, it is necessary to carry the tenant identity token in the access service request for the interceptor to verify, and execute the corresponding login state tenant access service request processing logic, such as entering the corresponding tenant Access the service interface, have the custom function corresponding to calling the tenant access service, and have the interaction authority to communicate with the platform server, etc.

208. Obtain and parse corresponding tenant information according to the tenant credential information to obtain tenant identification information;

209. Determine whether the tenant credential information is a tenant identity token;

210. If the tenant credential information is a tenant identity token, create a session object corresponding to the tenant client based on the tenant identity token;

211. Generate session identification information corresponding to the session object and send it to the tenant client for saving;

212. Save the tenant information to the session object, and invoke a corresponding implementation class according to the tenant information stored in the session object.

In this embodiment, in the tenant access service in the login state, after receiving a tenant access request with a tenant identity token, the tenant identity token in the tenant access request needs to be verified, and if the verification is successful, it is a tenant customer The client creates the corresponding session object and stores the tenant information for interacting with the function call of the platform server. If the user calls function A through the tenant client, the function implementation class corresponding to the realization function A is obtained by communicating with the platform server through the session object.

In this embodiment, the platform server generates corresponding session identification information for each tenant access service, which is stored by the platform server on the one hand, and sent to the tenant client and stored as a cookie on the other hand.

In this embodiment, for the session identification information in the business processing request initiated by the tenant client, the tenant information to which the tenant access service belongs is obtained from the session object, and is stored in the storage area of the platform server, so as to call according to the tenant information The corresponding implementation class.

213. Determine, according to the tenant identification information, an application context corresponding to the access service of the tenant client, and assign it to the thread where the access service request is located.

214. Receive a service processing request with the session identification information and the first identification information or the second identification information initiated when the tenant client invokes the customization function;

215. Determine, according to the session identification information, a session object corresponding to the tenant client;

216. Determine, according to the first identification information or the second identification information, a function implementation class corresponding to the tenant information stored in the session object, and instantiate an application context interface corresponding to client service processing through the function implementation class.

In this embodiment, the header of the service processing request initiated by the tenant client when invoking the customization function will carry the session identification information for the platform server to retrieve the corresponding session object, and also carry the identification information of the implementation class corresponding to the implementation of the customization function. For the platform server to identify the function implementation class that needs to be obtained.

In this embodiment, the user's invocation of the customized function on the virtual application platform is based on the instantiation of the application context interface by the function implementation class, and the instantiation of the application context interface is realized by a dynamic proxy. When the user invokes the custom function, the tenant information is obtained from the session object created by the tenant server when the tenant client logs in, and the interface corresponding to the instantiation of the function implementation class corresponding to the custom function is obtained.

In the embodiment of the present invention, after the user clicks to log in to the client, the QR code of the login client is displayed on the authentication and authorization page for the second client to scan and perform biometric authentication and user click authorization on the login client; If the second client has authorized the login client, log in directly without authentication and authorization; if the second client has not authorized the login client, it needs to perform initial authentication and authorization, and then log in directly to achieve Password-free login of the second client to the first client.

The method for implementing a multi-tenant access service in the embodiment of the present invention is described above, and the device for implementing a multi-tenant access service in the embodiment of the present invention is described below. Please refer to FIG. 3 , an embodiment of the device for implementing a multi-tenant access service in the embodiment of the present invention. include:

A receiving module 301, configured to read a tenant configuration file, where the tenant configuration file includes a custom function implementation class and/or a general function implementation class corresponding to each tenant access service;

A creation module 302, configured to create an application context corresponding to each tenant access service based on the custom function implementation class and/or general function implementation class corresponding to each tenant access service;

A parsing module 303, configured to receive and parse an access service request initiated by a tenant client to obtain tenant credential information corresponding to the tenant client; acquire and parse corresponding tenant information according to the tenant credential information to obtain tenant identification information;

The allocation module 304 is configured to determine, according to the tenant identification information, an application context corresponding to the access service of the tenant client and allocate it to the thread where the access service request is located.

In this embodiment of the present invention, when the user logs in to the first client, an HTTP authentication request is initiated to the authentication server, and the authentication server generates a two-dimensional code with identification information of the first client by parsing the authentication request; the second client By scanning the QR code, an authentication request is initiated to the authentication server, and the authentication server is requested to determine whether the authentication server has authorized the first client to log in without password; if the second client has authorized the first client, Then the authentication server does not need to authenticate the user corresponding to the authentication server again, and the second client directly authorizes the password-free login to the first client; if the second client has not authorized the first client, the authentication server is required. The authentication server authenticates the user, and after the authentication is completed, the second client authorizes a password-free login to the first client and stores the authorization record, and responds to the first client by returning to the first client with the user information acquisition code. The HTTP authentication request initiated by the client has passed. The first client terminal can also obtain the user information corresponding to the second client terminal through the user information acquisition code. Through this embodiment, the second client can implement password-free login to the first client.

Referring to FIG. 4 , another embodiment of an apparatus for implementing a multi-tenant access service in an embodiment of the present invention includes:

A receiving module 401, configured to read a tenant configuration file, where the tenant configuration file includes a custom function implementation class and/or a general function implementation class corresponding to each tenant access service;

A creation module 402, configured to create an application context corresponding to each tenant access service based on the custom function implementation class and/or the general function implementation class corresponding to each tenant access service;

A parsing module 403, configured to receive and parse an access service request initiated by a tenant client to obtain tenant credential information corresponding to the tenant client; acquire and parse corresponding tenant information according to the tenant credential information to obtain tenant identification information;

The allocation module 404 is configured to determine, according to the tenant identification information, an application context corresponding to the access service of the tenant client and allocate it to the thread where the access service request is located.

Specifically, the device for implementing multi-tenant access services further includes a startup module 405, which is specifically used for:

Load the preset default application context to implement common functions for each tenant to access services;

Determine whether the interface required by the default application context corresponds to one or more general function implementation classes;

If it corresponds to a general function implementation class, the general function implementation class is used as the implementation class corresponding to the interface of the default application context;

If it corresponds to multiple general function implementation classes, select one of the preset general function implementation classes as the implementation class corresponding to the interface required by the default application context.

Specifically, the creation module 402 includes a parsing unit 4021, a screening unit 4022, and a matching unit 4023, which are used for:

A first parsing unit 4021, configured to parse the tenant configuration file, and obtain a custom function implementation class with first identification information and/or a general function implementation class with second identification information corresponding to each tenant access service;

A screening unit 4022, configured to determine the application context and each custom function implementation class and/or the required interface of each tenant access service corresponding to the application context based on the first identification information and/or the second identification information The association between the general function implementation classes;

The matching unit 4023 is configured to bind the required interface with the corresponding custom function implementation class and/or general function implementation class based on the association relationship, generate an application context corresponding to each tenant access service, and use the corresponding tenant's Tenant identification information for identification.

Specifically, the parsing module 403 includes an intercepting unit 4031, a discriminating unit 4032, and an parsing unit 4033, which are used for:

Intercepting unit 4031, configured to intercept the access service request initiated by the tenant client;

A discriminating unit 4032, configured to determine the access service type of the tenant client according to the access service request;

The second parsing unit 4033 is configured to parse the access service request if the access service type is a non-login access service, and obtain the tenant credential information corresponding to the tenant client as the secret key; if the access service type In order to access the service in a login state, the access service request is parsed, and the tenant credential information corresponding to the tenant client is obtained as a tenant identity token.

Specifically, the multi-tenant access service implementation apparatus further includes a recording module 406, which is used for:

If the tenant credential information is a tenant identity token, create a session object corresponding to the tenant client based on the tenant identity token;

generating the session identification information corresponding to the session object and sending it to the tenant client for saving;

The tenant information is saved to the session object, and a corresponding implementation class is called according to the tenant information stored in the session object.

Specifically, the allocation module 404 is also used for:

receiving a service processing request with the session identification information and the first identification information or the second identification information initiated when the tenant client invokes the customization function;

determining, according to the session identification information, a session object corresponding to the tenant client;

According to the first identification information or the second identification information, a corresponding function implementation class in the tenant information stored in the session object is determined, and an application context interface corresponding to client business processing is instantiated through the function implementation class.

In the embodiment of the present invention, after the user clicks to log in to the client, the QR code of the login client is displayed on the authentication and authorization page for the second client to scan and perform biometric authentication and user click authorization on the login client; If the second client has authorized the login client, log in directly without authentication and authorization; if the second client has not authorized the login client, it needs to perform initial authentication and authorization, and then log in directly to achieve Password-free login of the second client to the first client.

3 and 4 above describe in detail the device for implementing multi-tenant access services in the embodiments of the present invention from the perspective of modular functional entities, and the following describes devices for implementing multi-tenant access services in embodiments of the present invention from the perspective of hardware processing.

5 is a schematic structural diagram of a device for implementing multi-tenant access services according to an embodiment of the present invention. The device 500 for implementing multi-tenant access services may vary greatly due to different configurations or performances, and may include one or more processors Central processing units (CPU) 510 (eg, one or more processors) and memory 520 , one or more storage media 530 (eg, one or more mass storage devices) that store application programs 533 or data 532 . Among them, the memory 520 and the storage medium 530 may be short-term storage or persistent storage. The program stored in the storage medium 530 may include one or more modules (not shown in the figure), and each module may include a series of instruction operations in the device 500 for implementing the multi-tenant access service. Furthermore, the processor 510 may be configured to communicate with the storage medium 530 to execute a series of instruction operations in the storage medium 530 on the device 500 for implementing the multi-tenant access service.

The multi-tenant access service implementation device 500 may also include one or more power supplies 540, one or more wired or wireless network interfaces 550, one or more input and output interfaces 560, and/or, one or more operating systems 531, such as Windows Serve, Mac OS X, Unix, Linux, FreeBSD and many more. Those skilled in the art can understand that the multi-tenant access service implementation device structure shown in FIG. 5 does not constitute a limitation on the multi-tenant access service implementation device, and may include more or less components than those shown in the figure, or combine some components , or a different component arrangement.

The present invention also provides a computer-readable storage medium. The computer-readable storage medium may be a non-volatile computer-readable storage medium. The computer-readable storage medium may also be a volatile computer-readable storage medium. Instructions are stored in the computer-readable storage medium, and when the instructions are executed on a computer, cause the computer to execute the steps of the method for implementing the multi-tenant access service.

Further, the computer-readable storage medium may mainly include a storage program area and a storage data area, wherein the storage program area may store an operating system, an application program required by at least one function, and the like; The data created by the use of the node, etc.

Those skilled in the art can clearly understand that, for the convenience and brevity of description, the specific working process of the system, device and unit described above may refer to the corresponding process in the foregoing method embodiments, which will not be repeated here.

The integrated unit, if implemented in the form of a software functional unit and sold or used as an independent product, may be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the present invention is essentially or the part that contributes to the prior art, or all or part of the technical solution can be embodied in the form of a software product, and the computer software product is stored in a storage medium , including several instructions for causing a computer device (which may be a personal computer, a server, or a network device, etc.) to execute all or part of the steps of the methods described in the various embodiments of the present invention. The aforementioned storage medium includes: U disk, removable hard disk, read-only memory (ROM), random access memory (RAM), magnetic disk or optical disk and other media that can store program codes .

The blockchain referred to in the present invention is a new application mode of computer technologies such as distributed data storage, point-to-point transmission, consensus mechanism, and encryption algorithm. Blockchain, essentially a decentralized database, is a series of data blocks associated with cryptographic methods. Each data block contains a batch of network transaction information to verify its Validity of information (anti-counterfeiting) and generation of the next block. The blockchain can include the underlying platform of the blockchain, the platform product service layer, and the application service layer.

As mentioned above, the above embodiments are only used to illustrate the technical solutions of the present invention, but not to limit them; although the present invention has been described in detail with reference to the foregoing embodiments, those of ordinary skill in the art should understand: The technical solutions described in the embodiments are modified, or some technical features thereof are equivalently replaced; and these modifications or replacements do not make the essence of the corresponding technical solutions depart from the spirit and scope of the technical solutions of the embodiments of the present invention.

Claims (10)

1. A method for realizing multi-tenant access service is characterized by comprising the following steps:

reading a tenant configuration file, wherein the tenant configuration file comprises a customized function implementation class and/or a general function implementation class corresponding to each tenant access service;

establishing an application context corresponding to each tenant access service based on the customized function implementation class and/or the general function implementation class corresponding to each tenant access service;

receiving and analyzing an access service request initiated by a tenant client to obtain tenant certificate information corresponding to the tenant client;

acquiring and analyzing corresponding tenant information according to the tenant certificate information to obtain tenant identification information;

and determining an application context corresponding to the tenant client access service according to the tenant identification information and distributing the application context to the thread where the access service request is located.

2. The method according to claim 1, wherein before the step of reading the tenant configuration file, where the tenant configuration file includes a customized function implementation class and/or a generic function implementation class corresponding to each tenant access service, the method further comprises:

loading a preset default application context for realizing the general function of each tenant access service;

judging whether the interface required by the default application context corresponds to one or more general function implementation classes;

if the application context corresponds to a general function implementation class, taking the general function implementation class as an implementation class corresponding to the interface of the default application context;

and if the application context corresponds to a plurality of general function implementation classes, selecting one preset general function implementation class as the implementation class corresponding to the interface required by the default application context.

3. The method according to claim 1, wherein the creating an application context corresponding to each tenant access service based on the customized function implementation class and/or the generic function implementation class corresponding to each tenant access service comprises:

analyzing the tenant configuration file to obtain a customized function implementation class with first identification information and/or a general function implementation class with second identification information corresponding to each tenant access service;

determining an incidence relation between the application context and each customized function implementation class and/or each general function implementation class based on the first identification information and/or the second identification information and a required interface of the application context corresponding to each tenant access service;

and based on the incidence relation, binding the required interface with the corresponding customized function implementation class and/or general function implementation class, generating an application context corresponding to each tenant access service, and identifying by using tenant identification information of the corresponding tenant.

4. The method for implementing multi-tenant access service according to claim 1, wherein the receiving and analyzing an access service request initiated by a tenant client to obtain tenant credential information corresponding to the tenant client comprises:

intercepting an access service request initiated by the tenant client;

determining the access service type of the tenant client according to the access service request;

if the access service type is a non-login access service, analyzing the access service request to obtain tenant certificate information corresponding to the tenant client as a secret key;

and if the access service type is the login state access service, analyzing the access service request to obtain the tenant certificate information corresponding to the tenant client as a tenant identity token.

5. The method for implementing multi-tenant access service according to claim 4, wherein after the step of obtaining and analyzing corresponding tenant information according to the tenant credential information to obtain tenant identification information, the method further comprises:

if the tenant certificate information is a tenant identity token, establishing a session object corresponding to the tenant client based on the tenant identity token;

generating session identification information corresponding to the session object and sending the session identification information to the tenant client for storage;

and saving the tenant information to the session object, and calling a corresponding implementation class according to the tenant information stored in the session object.

6. The method for implementing multi-tenant access service according to claim 1, wherein after the step of determining an application context corresponding to the tenant client access service according to the tenant identification information and allocating the application context to the thread where the access service request is located, the method further comprises:

receiving a service processing request with the session identification information and the first identification information or the second identification information, which is initiated when the tenant client calls a customization function;

determining a session object corresponding to the tenant client according to the session identification information;

and determining a corresponding function implementation class in tenant information stored in the session object according to the first identification information or the second identification information, and instantiating an application context interface corresponding to the client service processing through the function implementation class.

7. A multi-tenant access service implementation apparatus, wherein the multi-tenant access service implementation apparatus comprises:

the system comprises a receiving module, a processing module and a processing module, wherein the receiving module is used for reading a tenant configuration file, and the tenant configuration file comprises a customized function implementation class and/or a general function implementation class corresponding to each tenant access service;

the creation module is used for creating an application context corresponding to each tenant access service based on the customized function implementation class and/or the general function implementation class corresponding to each tenant access service;

the analysis module is used for receiving and analyzing an access service request initiated by a tenant client to obtain tenant certificate information corresponding to the tenant client; acquiring and analyzing corresponding tenant information according to the tenant certificate information to obtain tenant identification information;

and the distribution module is used for determining the application context corresponding to the tenant client access service according to the tenant identification information and distributing the application context to the thread where the access service request is located.

8. The multi-tenant access service implementation apparatus of claim 7, wherein the creation module further comprises:

the first analysis unit is used for analyzing the tenant configuration file to obtain a customized function implementation class with first identification information and/or a general function implementation class with second identification information corresponding to each tenant access service;

a screening unit, configured to determine, based on the first identification information and/or the second identification information and a required interface of an application context corresponding to each tenant access service, an association relationship between the application context and each customized function implementation class and/or each general function implementation class;

and the matching unit is used for binding the required interface with the corresponding customized function implementation class and/or general function implementation class based on the incidence relation, generating the application context corresponding to each tenant access service and identifying by using the tenant identification information of the corresponding tenant.

9. A multi-tenant access service implementation device, comprising: a memory having instructions stored therein and at least one processor, the memory and the at least one processor interconnected by a line;

the at least one processor invokes the instructions in the memory to cause the multi-tenant access service implementation device to perform the multi-tenant access service implementation method of any of claims 1-6.

10. A computer-readable storage medium comprising a data storage area storing data created according to use of a blockchain node and a program storage area storing a computer program, wherein the computer program when executed by a processor implements the multi-tenant access service implementation method of any one of claims 1-6.

Images