CN117914721A

CN117914721A - Java-based call substitute service system construction method and device

Info

Publication number: CN117914721A
Application number: CN202311676319.1A
Authority: CN
Inventors: 张雅核
Original assignee: China Unicom Online Information Technology Co Ltd
Current assignee: China Unicom Online Information Technology Co Ltd
Filing date: 2023-12-07
Publication date: 2024-04-19

Abstract

The application discloses a Java-based call access service system construction method and equipment, and belongs to the technical field of communication. The method comprises the following steps: designing a double-node architecture; according to the load balancing strategy, configuring a load balancer, and distributing a user request to a proper node; deploying a fault-tolerant mechanism on each node, and automatically switching to another node when a node fault is detected; backing up original data on each node respectively, and making a data migration plan; performing data migration operation according to the formulated data migration plan, and migrating stock data from an original node to a new node, wherein the original node is a first node, the new node is a second node, or the original node is a second node, and the new node is a first node; the real-time synchronization of the data between the double nodes is realized by a data synchronization technology; and developing an authentication function on the double nodes and optimizing an authentication flow. The application realizes nearby authentication, quick response and improves user experience.

Description

Java-based call substitute service system construction method and device

Technical Field

The application belongs to the technical field of communication, and particularly relates to a Java-based call access service system construction method and equipment.

Background

In the existing call substitute service, because the service processing node is single, when the node fails, service interruption in the whole country can be caused, and the user experience is seriously affected. Therefore, how to improve the stability and usability of the call substitute service is a current urgent problem to be solved.

Aiming at the problems, the application provides a Java-based call access service system construction method and equipment.

Disclosure of Invention

In order to solve the defects of the prior art, the application provides a Java-based call proxy service system construction method and Java-based call proxy service system construction equipment, and solves the problems that in the prior art, service processing nodes are single, service interruption in the whole country can be caused when the nodes fail, user experience is seriously affected and the like.

The technical effects to be achieved by the application are realized by the following scheme:

In a first aspect, the present application provides a method for constructing a Java-based call proxy service system, where the method includes:

S1, designing a dual-node architecture, wherein the dual nodes involved in the dual-node architecture comprise a first node and a second node, relevant equipment and software are deployed on the first node and the second node respectively, a first master server and a first slave server are deployed on the first node, and a second master server and a second slave server are deployed on the second node;

s2, configuring a load balancer according to a load balancing strategy, and distributing a user request to a proper node;

s3, deploying a fault-tolerant mechanism on each node, and automatically switching to another node when a node fault is detected;

S4, backing up original data on each node respectively, and making a data migration plan;

s5, executing data migration operation according to the formulated data migration plan, and migrating stock data from an original node to a new node, wherein the original node is the first node, the new node is the second node, or the original node is the second node, and the new node is the first node;

s6, realizing the real-time synchronization of the data between the double nodes by a data synchronization technology;

s7, developing an authentication function on the double nodes and optimizing an authentication flow.

In some embodiments, the method further comprises:

s8, setting a security detection rule according to security requirements to prevent the leakage and the tampering of the authentication information.

In some embodiments, the implementing the real-time synchronization of the data between the dual nodes by using a data synchronization technology includes:

generating a PSYNC command by the first node when the first main server of the first node has data change;

The first node sends the PSYNC command to the second slave server of the second node through a publish-subscribe function;

after the second slave server of the second node receives the PSYNC command, the PSYNC command is executed, and the second slave server reacquires all data changes generated by the first master server after the last synchronization and applies the data changes to the data set of the second slave server, so that the purpose of synchronizing the data sets between the second slave server and the first master server is achieved.

And after the second slave server of the second node completes execution of the PSYNC command, executing a data set synchronization flow between the second master server and the second slave server of the second node, and further completing data set synchronization between the second master server and the second slave server of the second node.

In some embodiments, the developing the authentication function on the dual node and optimizing the authentication flow includes:

Storing the ordering state of the user through a Redis bitmap, and realizing authentication for the user based on the Redis bitmap.

In some embodiments, the storing the subscription status of the user through the Redis bitmap and implementing authentication for the user based on the Redis bitmap includes:

When the user logs in, the system generates an ID (identity) for uniquely identifying the user, wherein the receiving node is the first node or the second node;

The system uses the ID as an index to generate a Redis bitmap in a Redis, wherein the Redis bitmap corresponds to the state information of the user, and each bit of the Redis bitmap represents the state of a service or a product;

The system uses binary values to represent the different states.

When the state information of the user needs to be queried, the system acquires a Redis bitmap corresponding to the user from the Redis.

In some embodiments, the storing the subscription status of the user through the Redis bitmap, and implementing authentication for the user based on the Redis bitmap, further includes:

the system analyzes the Redis bitmap corresponding to the user, and determines the state of the service or the product corresponding to the user by looking up the value of each bit in the Redis bitmap.

Performing authentication operation according to the determined state of the service or the product corresponding to the user;

and updating the Redis bitmap corresponding to the user by the system according to the authentication result.

In some embodiments, the system employs binary values to represent different states, including:

If the binary value is 1, the corresponding service or product is subscribed to by the user;

if the binary value is 0, it indicates that the corresponding service or product is not subscribed to by the user.

And deleting the Redis bitmap corresponding to the user when the user exits the real-time system.

In a second aspect, the present application provides an apparatus comprising: a memory, a processor and a computer program stored on the memory and executable on the processor, the processor implementing the method of any one of the preceding claims when the computer program is executed.

In a third aspect, the present application provides a computer readable storage medium storing one or more programs executable by one or more processors to implement the method of any of the preceding claims.

The Java-based call access service system construction method and the Java-based call access service system construction equipment realize related operations such as modern access, authentication and the like through the dual-node architecture, and particularly realize load balancing among dual nodes through a load balancing technology, so that the system performance is improved; through fault tolerance technology, when one node fails, the other node can automatically take over service, and service continuity is ensured. The application realizes nearby authentication, quick response and improves user experience.

Drawings

In order to more clearly illustrate the embodiments of the application or the prior art solutions, the drawings which are used in the description of the embodiments or the prior art will be briefly described below, it being obvious that the drawings in the description below are only some of the embodiments described in the present application, and that other drawings can be obtained according to these drawings without inventive effort for a person skilled in the art.

FIG. 1 is a flowchart of a method for constructing a Java-based call attach service system according to an embodiment of the present application;

Fig. 2 is a schematic block diagram of an apparatus in an embodiment of the application.

Detailed Description

In order to make the objects, technical solutions and advantages of the present application more apparent, the technical solutions of the present application will be clearly and completely described below with reference to specific embodiments and corresponding drawings. It will be apparent that the described embodiments are only some, but not all, embodiments of the application. All other embodiments, which can be made by those skilled in the art based on the embodiments of the application without making any inventive effort, are intended to be within the scope of the application.

It is to be noted that unless otherwise defined, technical or scientific terms used in one or more embodiments of the present application should be taken in a general sense as understood by one of ordinary skill in the art to which the present application belongs. The use of the terms "first," "second," and the like in one or more embodiments of the present application does not denote any order, quantity, or importance, but rather the terms "first," "second," and the like are used to distinguish one element from another. The word "comprising" or "comprises", and the like, means that elements or items preceding the word are included in the element or item listed after the word and equivalents thereof, but does not exclude other elements or items. The terms "connected" or "connected," and the like, are not limited to physical or mechanical connections, but may include electrical connections, whether direct or indirect. "upper", "lower", "left", "right", etc. are used merely to indicate relative positional relationships, which may also be changed when the absolute position of the object to be described is changed.

The application mainly comprises the following steps:

(1) Backing up data: respectively backing up stock data of different nodes;

(2) And (3) data migration: migrating the stock data of the first node to a second node, and migrating the second stock data to the first node;

(3) Data synchronization: and through a data synchronization technology, the real-time synchronization of data between the double nodes is realized.

(4) And (3) developing an authentication function: developing authentication function on the double nodes to realize verification of user authentication information;

(5) And (3) optimizing an authentication flow: the authentication efficiency is improved by optimizing the authentication flow;

(6) Safety enhancement: by enhancing security measures, leakage and tampering of authentication information are prevented.

Various non-limiting embodiments of the present application are described in detail below with reference to the attached drawing figures.

First, a detailed description will be given of a Java-based call pickup service system construction method according to the present application with reference to fig. 1. As shown in fig. 1, the present application provides a method for constructing a call proxy service system based on Java, which includes:

Specifically, the above embodiment of the present application can achieve the following technical effects:

(1) Designing a double-node architecture: respectively constructing service nodes at different places (two places far away) to realize a double-activity state; and through the packaging tool, the data change event is monitored in real time, and the low-time delay synchronization of the two-place data is ensured.

(2) Designing a load balancing mechanism: load balancing between the double nodes is realized through a load balancing technology, and the system performance is improved;

(3) Designing a fault-tolerant mechanism: through fault tolerance technology, when one node fails, the other node can automatically take over service, and service continuity is ensured.

In some embodiments, the method further comprises:

The system uses binary values to represent the different states.

In particular, the system may be, for example, a system applied to the dual node structure, which may determine an appropriate node for authenticating a user based on the location information of the user; for example, in case the user is closer to the first node than to the second node, an authentication request of the user may be sent to the first node, i.e. authentication is implemented according to a proximity principle; the authentication request may be allocated according to other principles, for example.

The data synchronization part adopts Redis native commands to build a low-delay architecture.

The following is illustrated by way of example:

Example 1

1. The first node generates a PSYNC command: when the Redis cluster first host server of the first node has a data change, the host server will generate a PSYNC command. The PSYNC command is a command for Redis to synchronize data, which is used to notify the slave servers (corresponding to the first slave server and the second slave server above): "all data changes that occur from the last synchronization to the master server, need to be retrieved from the slave server and applied to the slave server's data set".

2. The first node synchronizes the PSYNC command to a second slave server of the second node through a publish-subscribe function: the first node sends the generated PSYNC command to a second slave server of the second node through a Redis publishing and subscribing function. The publish-subscribe function is a messaging mode: the publisher (which in this scenario may be the first node) publishes messages (PSYNC commands) and the subscriber (which in this scenario may be the second slave server of the second node) receives and processes these messages.

3. The second slave server of the second node executes the PSYNC command: after receiving the PSYNC command, the second slave server of the second node executes the command. This means that the second slave server will retrieve all data changes that have occurred since the last synchronization with the first master server and apply to its own data set, thereby achieving the purpose of data synchronization with the first master server.

4. The second primary server of the second node synchronizes data: when the second slave server of the second node completes execution of the PSYNC command, the master-slave replication process is completed. The dataset of the second primary server of the second node is now already synchronized with the dataset of the first primary server of the first node.

Example 2

Service authentication stores a user's subscription status through a dis Bitmap (Bitmap), and can efficiently process a large amount of user status information. The overall authentication process is as follows:

1. User login: upon user login, the system generates an ID, e.g., UUID, that uniquely identifies the user.

2. Generating a bitmap: the system uses the user's ID as an index to generate a bitmap in Redis. Each bit of this bitmap represents the status of a particular service or product, for example: whether music packs are ordered, whether movie packs are ordered, etc.

3. Setting a bitmap: the system will convert the user's status information into binary form and set to the corresponding bit. For example: if the user subscribes to the music package, then set to 1 on the bit corresponding to the music package; otherwise, setting to 0; here, the reverse can be set, i.e. if the user has subscribed to the music package, then set to 0 on the corresponding bit of the music package; otherwise set to 1.

4. Obtaining a bitmap: whenever the status information of a user needs to be queried, the system will acquire the bitmap of the user from Redis.

5. Analyzing the bitmap: the system parses the bitmap to determine if the user has subscribed to the corresponding service or product by looking at the place where the bit is 1.

6. Authentication: and according to the analyzed state information, the system performs authentication operation. For example: if the user does not subscribe to the music package, the user cannot enjoy the music service.

7. Updating the bitmap: based on the authentication result, the system may update the bitmap of the user. For example: if the user purchases a new service or product in the system, the corresponding bit needs to be updated to 1 (or 0, corresponding to another setting in step 3).

8. Exiting: when the user exits the system, the corresponding bitmap is deleted.

By storing user state information by means of a bitmap of Redis, a large amount of user state information can be handled very efficiently, since the bitmap is a compact binary data structure. In addition, the relevant operation for Redis can also ensure the consistency and the safety of data in a multi-thread environment.

The application realizes the following advantages and effects through the architecture design of the remote double-active service authentication, the stock data migration and the construction of the remote service authentication system:

1. The stability and the usability of call substitute services are improved;

2. the nearby authentication is realized, the response is quick, and the user experience is improved;

3. the expandability and maintainability of the system are enhanced;

4. The safety and the reliability of the system are improved.

It should be noted that the method according to one or more embodiments of the present application may be performed by a single device, such as a computer or server. The method of the embodiment can also be applied to a distributed scene, and is completed by mutually matching a plurality of devices. In the case of such a distributed scenario, one of the devices may perform only one or more steps of the methods of one or more embodiments of the present application, the devices interacting with each other to accomplish the methods.

It should be noted that the foregoing describes specific embodiments of the present application. Other embodiments are within the scope of the following claims. In some cases, the actions or steps recited in the claims can be performed in a different order than in the embodiments and still achieve desirable results. In addition, the processes depicted in the accompanying figures do not necessarily require the particular order shown, or sequential order, to achieve desirable results. In some embodiments, multitasking and parallel processing are also possible or may be advantageous.

Based on the same inventive concept, the application also discloses an electronic device corresponding to the method of any embodiment;

Specifically, fig. 2 shows a schematic hardware structure of a device of the method for constructing a Java-based call proxy service system according to the present embodiment, where the device may include: processor 410, memory 420, input/output interface 430, communication interface 440, and bus 450. Wherein processor 410, memory 420, input/output interface 430 and communication interface 440 are communicatively coupled to each other within the device via bus 450.

The processor 410 may be implemented by a general-purpose CPU (Central Processing Unit ), a microprocessor, an Application SPECIFIC INTEGRATED Circuit (ASIC), or one or more integrated circuits, etc. for executing related programs to implement the technical solutions provided by the embodiments of the present application.

The memory 420 may be implemented in the form of ROM (read only memory), RAM (Random Access Memory ), static storage, dynamic storage, etc. Memory 420 may store an operating system and other application programs, and when implementing the techniques provided by embodiments of the present application by software or firmware, the associated program code is stored in memory 420 and invoked for execution by processor 410.

The input/output interface 430 is used to connect with an input/output module to realize information input and output. The input/output module may be configured as a component in a device (not shown in the figure) or may be external to the device to provide corresponding functionality. Wherein the input devices may include a keyboard, mouse, touch screen, microphone, various types of sensors, etc., and the output devices may include a display, speaker, vibrator, indicator lights, etc.

The communication interface 440 is used to connect communication modules (not shown) to enable communication interactions of the device with other devices. The communication module may implement communication through a wired manner (e.g., USB, network cable, etc.), or may implement communication through a wireless manner (e.g., mobile network, WIFI, bluetooth, etc.).

Bus 450 includes a path to transfer information between components of the device (e.g., processor 410, memory 420, input/output interface 430, and communication interface 440).

It should be noted that although the above device only shows the processor 410, the memory 420, the input/output interface 430, the communication interface 440, and the bus 450, in the implementation, the device may further include other components necessary to achieve normal operation. Furthermore, it will be understood by those skilled in the art that the above-described apparatus may include only the components necessary for implementing the embodiments of the present application, and not all the components shown in the drawings.

The electronic device of the foregoing embodiment is configured to implement the corresponding method for constructing the Java-based call proxy service system in any of the foregoing embodiments, and has the beneficial effects of the corresponding method embodiment, which is not described herein.

Based on the same inventive concept, one or more embodiments of the present application also provide a non-transitory computer readable storage medium storing computer instructions for causing the computer to perform the Java-based call pickup service system construction method according to any of the embodiments.

The computer readable media of the present embodiments, including both permanent and non-permanent, removable and non-removable media, may be used to implement information storage by any method or technology. The information may be computer readable instructions, data structures, modules of a program, or other data. Examples of storage media for a computer include, but are not limited to, phase change memory (PRAM), static Random Access Memory (SRAM), dynamic Random Access Memory (DRAM), other types of Random Access Memory (RAM), read Only Memory (ROM), electrically Erasable Programmable Read Only Memory (EEPROM), flash memory or other memory technology, compact disc read only memory (CD-ROM), digital Versatile Discs (DVD) or other optical storage, magnetic cassettes, magnetic tape disk storage or other magnetic storage devices, or any other non-transmission medium, which can be used to store information that can be accessed by a computing device.

The storage medium of the foregoing embodiment stores computer instructions for causing the computer to execute the method for constructing a Java-based call pickup service system according to any one of the foregoing embodiments, and has the beneficial effects of the corresponding method embodiments, which are not described herein.

Those of ordinary skill in the art will appreciate that: the discussion of any of the embodiments above is merely exemplary and is not intended to suggest that the scope of the application (including the claims) is limited to these examples; combinations of features of the above embodiments or in different embodiments are also possible within the spirit of the application, steps may be implemented in any order and there are many other variations of the different aspects of one or more embodiments of the application described above which are not provided in detail for the sake of brevity.

Additionally, well-known power/ground connections to Integrated Circuit (IC) chips and other components may or may not be shown within the provided figures, in order to simplify the illustration and discussion, and so as not to obscure one or more embodiments of the application. Furthermore, the apparatus may be shown in block diagram form in order to avoid obscuring the embodiment(s) of the present application, and also in view of the fact that specifics with respect to implementation of such block diagram apparatus are highly dependent upon the platform on which the embodiment(s) of the present application are to be implemented (i.e., such specifics should be well within purview of one skilled in the art). Where specific details (e.g., circuits) are set forth in order to describe example embodiments of the application, it should be apparent to one skilled in the art that one or more embodiments of the application can be practiced without, or with variation of, these specific details. Accordingly, the description is to be regarded as illustrative in nature and not as restrictive.

While the application has been described in conjunction with specific embodiments thereof, many alternatives, modifications, and variations of those embodiments will be apparent to those skilled in the art in light of the foregoing description. For example, other memory architectures (e.g., dynamic RAM (DRAM)) may use the embodiments discussed.

The present application is intended to embrace all such alternatives, modifications and variances which fall within the broad scope of the appended claims. Accordingly, any omissions, modifications, equivalents, improvements and others which are within the spirit and principle of the one or more embodiments of the application are intended to be included within the scope of the application.

Claims

1. A Java-based call access service system construction method is characterized by comprising the following steps:

2. The Java-based call pickup service system construction method according to claim 1, further comprising:

3. The method for constructing a Java-based call pickup service system according to claim 1 or 2, wherein the implementing the real-time synchronization of data between the dual nodes by the data synchronization technique includes:

4. The method for constructing a Java-based call pickup service system according to claim 3, wherein developing an authentication function on the dual node and optimizing an authentication flow comprises:

5. The method for constructing a Java-based call-instead-access service system according to claim 4, wherein the storing the subscription status of the user through the dis bitmap and implementing the authentication for the user based on the dis bitmap comprises:

The system uses binary values to represent the different states.

6. The method for constructing a Java-based call access service system according to claim 5, wherein the storing the subscription status of the user through the Redis bitmap and implementing authentication for the user based on the Redis bitmap further comprises:

7. The method for constructing a Java-based call-instead-of-connect service system according to claim 6, wherein the system adopts binary values to represent different states, comprising:

8. The method for constructing a Java-based call access service system according to claim 6, wherein the storing the subscription status of the user through the Redis bitmap and implementing authentication for the user based on the Redis bitmap further comprises:

9. An apparatus, the apparatus comprising: memory, a processor and a computer program stored on the memory and executable on the processor, characterized in that the processor implements the method according to any of claims 1 to 8 when executing the computer program.

10. A computer readable storage medium storing one or more programs executable by one or more processors to implement the method of any of claims 1-8.