CN115421766A - Non-core service decoupling method and device - Google Patents
Non-core service decoupling method and device Download PDFInfo
- Publication number
- CN115421766A CN115421766A CN202211046184.6A CN202211046184A CN115421766A CN 115421766 A CN115421766 A CN 115421766A CN 202211046184 A CN202211046184 A CN 202211046184A CN 115421766 A CN115421766 A CN 115421766A
- Authority
- CN
- China
- Prior art keywords
- core service
- core
- interface
- event
- service
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING OR CALCULATING; COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Telephonic Communication Services (AREA)
Abstract
The invention provides a non-core service decoupling method and a device, which relate to the technical field of service processing and can be used in the financial field, and the method comprises the following steps: the non-core service interface is declared through self-defined annotation, and the non-core service interface is used for configuring a service on the core service interface to realize the call of the non-core service; defining a non-core service interface to realize a non-core service, and taking the non-core service interface as an event subscriber; when the core service is called, the event of the non-core service is issued according to the custom annotation, and the non-core service interface is called through the event-driven model to realize the asynchronous processing of the non-core service and the core service. The method and the system can decouple the core business processing and the non-core business processing, improve the response speed of the system, enhance the stability, enable the business decoupling based on the custom annotation mode to be simpler and lighter in program development and use, and enable the program development to be more flexible and the maintenance and the expansion to be simpler and more convenient by using the event driving mode.
Description
Technical Field
The invention relates to the technical field of business processing, can be used in the financial field, and particularly relates to a non-core business decoupling method and device.
Background
In a service information system, especially a complex large-scale system, service processing logic is complex, core service processing is often accompanied by a plurality of non-core and necessary service processing logic, some of which require synchronous processing and some of which require asynchronous processing. The existing service information system thus has the following problems:
(1) The core service logic processing and the non-core service processing are mixed and mutually affect each other, and the complex processing logic can cause all failures due to processing failure of one point, the core service processing failure due to non-core service processing failure and the like.
(2) In the process of project development, part of non-core processing logic may be called at multiple places, and the codes are basically the same and different, such as log recording, short message sending and the like, so that a lot of redundant codes exist in the project due to no decoupling, and the unified management and the later maintenance and expansion are not facilitated.
Therefore, it is necessary to decouple the non-core service processing, but the current decoupling scheme is not light, simple and flexible enough, and cannot improve the code quality and the development efficiency during the project development.
Disclosure of Invention
In view of the above, the present invention provides a method and an apparatus for decoupling non-core services to solve at least one of the above-mentioned problems.
In order to achieve the purpose, the invention adopts the following scheme:
according to a first aspect of the present invention, there is provided a method of uncore traffic decoupling, the method comprising: a non-core service interface is declared through self-defined annotation, and the non-core service interface is used for configuring a service on the core service interface to realize the calling of the non-core service; defining the non-core service interface to realize the non-core service, and taking the non-core service interface as an event subscriber; and when the core service is called, issuing the event of the non-core service according to the custom annotation, and calling the non-core service interface through an event-driven model to realize asynchronous processing of the non-core service and the core service.
According to a second aspect of the present invention, there is provided an apparatus for uncore traffic decoupling, the apparatus comprising: the user-defined annotation unit is used for declaring a non-core service interface through user-defined annotation so as to configure the non-core service interface to realize the call of the non-core service; the interface definition unit is used for defining the non-core service interface to realize the non-core service and taking the non-core service interface as an event subscriber; the event issuing unit is used for issuing the event of the non-core service according to the custom annotation when the core service is called; and the service calling unit is used for calling the non-core service interface through the event-driven model so as to realize asynchronous processing of the non-core service and the core service.
According to a third aspect of the invention, there is provided an electronic device comprising a memory, a processor and a computer program stored on said memory and executable on said processor, the processor implementing the steps of the above method when executing said computer program.
According to a fourth aspect of the invention, a computer-readable storage medium is provided, on which a computer program is stored which, when being executed by a processor, carries out the steps of the above-mentioned method.
According to a fifth aspect of the invention, there is provided a computer program product comprising computer programs/instructions which, when executed by a processor, implement the steps of the above method.
According to the technical scheme, the non-core service decoupling method and the non-core service decoupling device can decouple core service processing and non-core service processing, improve the response speed of a system, enhance the stability and the robustness, enable the service decoupling based on a user-defined annotation mode to be simpler and lighter in program development and use, enable the non-core service processing to be realized by using an event driving mode, enable the program development to be more flexible, and enable the later maintenance and the expansion to be simpler and more convenient.
Drawings
In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings used in the description of the embodiments or the prior art will be briefly described below, it is obvious that the drawings in the following description are only some embodiments of the present invention, and for those skilled in the art, other drawings can be obtained according to the drawings without creative efforts. In the drawings:
fig. 1 is a schematic flowchart of a non-core service decoupling method according to an embodiment of the present disclosure;
fig. 2 is a schematic flowchart of a non-core service decoupling method according to another embodiment of the present application;
fig. 3 is a schematic structural diagram of a non-core service decoupling apparatus according to an embodiment of the present application;
fig. 4 is a schematic block diagram of a system configuration of an electronic device according to an embodiment of the present application.
Detailed Description
The method and the device for decoupling non-core services provided by the embodiment of the invention can be used in the financial field and other fields, and it should be noted that the method and the device for decoupling non-core services can be used in the financial field and any fields except the financial field.
In order to make the objects, technical solutions and advantages of the embodiments of the present invention more apparent, the embodiments of the present invention are further described in detail below with reference to the accompanying drawings. The exemplary embodiments and descriptions of the present invention are provided to explain the present invention, but not to limit the present invention.
The technical terms referred to in the present application are first briefly described below:
the term "Spring AOP", meaning a technique for realizing unified maintenance of program functions by means of pre-compiling and run-time dynamic proxy, is an important content in the Spring framework.
@ interface: an annotation is declared.
@ association: java annotations for matching methods for which the currently executing method holds the specified annotations.
@ Around: java note, surround enhancement.
@ Aspect: java annotation, statement section.
ApplicationEventPublisher: event publishing tool class in the event driven model of Spring.
Fig. 1 is a schematic flow chart of a non-core service decoupling method provided in an embodiment of the present application, where the method includes the following steps:
step S101: and a non-core service interface is declared through the self-defined annotation, and the non-core service interface is used for configuring a non-core service on the core service interface to realize the calling of the non-core service.
In this embodiment, the non-core service is generally a service for implementing some basic functions, and is usually called by multiple core services, such as short message notification, log recording, performance detection, permission setting, and the like.
An annotation is metadata that can be added to java code, and classes, methods, variables, parameters, and packages can be decorated with annotations, so that an annotation is actually a tag that can be marked on key nodes (classes, methods, variables, parameters, packages) in the program code, and then detected by the program at compile time or runtime to perform some special operations. In the embodiment, the non-core service interface is firstly declared through the self-defined annotation, then the self-defined annotation is configured into the core service interface program, and when the core service interface program is called, the self-defined annotation can be detected, so that the calling of the non-core service is realized.
Step S102: and defining the non-core service interface to realize the non-core service, and using the non-core service interface as an event subscriber.
The step is an implementation part of the non-core service, which can be implemented in an annotation type element in the user-defined annotation, and the implementation of the non-core service is written into the annotation type element of the user-defined annotation through a code.
Step S103: and when the core service is called, issuing the event of the non-core service according to the custom annotation, and calling the non-core service interface through an event-driven model to realize asynchronous processing of the non-core service and the core service.
According to the technical scheme, the non-core service decoupling method can decouple core service processing and non-core service processing, improves the response speed of a system, enhances the stability and the robustness, is simpler and lighter in program development and use due to service decoupling based on a user-defined annotation mode, is realized by using an event driving mode in the non-core service processing, can enable the program development to be more flexible, and is simpler and more convenient in later maintenance and expansion.
Fig. 2 is a schematic flow chart of another non-core service decoupling method provided in the embodiment of the present application, where the method includes the following steps:
step S201: and declaring a non-core service interface through the custom annotation @ interface, wherein the interface is used for configuring on the core service interface to realize the call of the non-core service.
Step S202: defining the non-core service interface to realize the non-core service, and using the non-core service interface as an event subscriber.
Step S203: declaring a non-core service section class, configuring surrounding enhancement by @ Around in the non-core service section class, pointing to a self-defined annotation of a non-core service interface by @ annotation, and calling ApplicationEventPublisher.
The AOP can intercept the appointed method and enhance the method, and does not need to invade into the service code, so that the service is separated from the non-service processing logic. In this embodiment, the generic function is an uncore service.
Step S204: and calling the non-core service interface through an event-driven model to realize asynchronous processing of the non-core service and the core service.
The non-core service decoupling method provided by the embodiment of the application is provided for a core service interface to use in a user-defined annotation mode on the principle of Spring AOP, and the non-core service processing method is internally realized through the applicationEventPublicher of an event-driven model, so that the purposes of flexible configuration, light weight and simplicity can be achieved while the core service processing and other non-core sub-service processing are decoupled. Not only improve the code quality, can also improve research and development efficiency, reduce the cost of later maintenance, expansion.
The above method is further described by two specific examples below:
the specific implementation case one is as follows:
and (4) service background: and after the daily management process passes examination and approval after the loan, informing a customer manager initiated by the service by a short message. In order to ensure the stability and the fluency of the core service approved by the process, the short message notification function is decoupled and then the short message is asynchronously sent. In the service environment, the core service is: and (3) after-credit daily management business approval process, wherein the non-core business is as follows: and (6) short message notification.
The implementation scheme is as follows:
1. the short message notification interface is used for configuring on an approval service interface (aprvService) and sending the short message through the self-defined annotation SendMessage statement.
2. And defining an implementation class Send for sending the short message to realize the function of sending the short message, and taking the implementation class Send as a subscriber for event publishing.
3. Based on the Spring AOP principle, a SendMessageAssiect section class is declared, surrounding enhancement is configured through @ Around, a custom annotation SendMessage is pointed through @ informing, and an applicationEventPublisher.
4. And calling a short message notification interface through the event-driven model to realize asynchronous processing of short message notification service and approval of daily management service after credit.
The method has the following effects: based on the design, when the daily management service approval service is called after loan, the note sent by the short message is configured, the event sent by the short message is issued, the short message sending interface is called through the event-driven model, the short message is sent asynchronously, and the service approval and the short message sending are processed asynchronously, so that the aim of decoupling the core service from the non-core service is fulfilled.
The specific implementation case two is as follows:
and (4) service background: in a credit system, aiming at sensitive information fields of partial customers, in order to improve the safety, the method sets partial business personnel to have authority to access the sensitive information, and the system records operation records of the business personnel accessing the sensitive information for auditing and management. In the service environment, the core service is: inquiring the sensitive information field of the client, wherein the non-core service comprises the following steps: and (6) logging.
The implementation scheme is as follows:
1. and declaring a log record interface through a custom comment ISnsvInfoLog for configuring on an access client sensitive information interface (getCustSnsvInfo) to realize log record.
2. Defining a SnsvInfoLog service interface of log records, realizing the log recording function, generating one record by client access at a time, recording the relevant information of specific accessed sensitive fields, access time, access ip and the like, and using the SnsvInfoLog service interface as a subscriber for event release.
3. Declaring an SnsvInfAsspect section class, configuring surrounding enhancement through @ Around, pointing to a custom annotation ISnsvInfoLog through @ indication, and calling an ApplicationEventPublisher.
4. And calling a logging interface through an event-driven model to realize asynchronous processing of sensitive information field operations of logging services and query clients.
The method has the following effects: based on the design, when service personnel access the client sensitive information, the interface for inquiring the client sensitive information is configured with the annotation of the log record, the log record interface is called through the event-driven model, the log record is asynchronously carried out, and the client sensitive information and the log record are asynchronously processed, so that the aim of decoupling the core service from the non-core service is fulfilled.
Fig. 3 is a schematic structural diagram of a non-core service decoupling apparatus provided in an embodiment of the present application, where the apparatus includes: the system comprises a custom annotation unit 310, an interface definition unit 320, an event publishing unit 330 and a service calling unit 340, which are connected in sequence.
The custom annotation unit 310 is configured to declare the non-core service interface through the custom annotation, so that the configuration is performed on the core service interface to implement the call to the non-core service.
The interface definition unit 320 is configured to define the non-core service interface to implement a non-core service, and use the non-core service interface as an event subscriber.
The event issuing unit 330 is configured to issue an event of the non-core service according to the custom annotation when a core service is called.
The service invoking unit 340 is configured to invoke the non-core service interface through an event-driven model to implement asynchronous processing of the non-core service and the core service.
Preferably, the event issuing unit 330 is specifically configured to: declaring a non-core service tangent plane class, configuring surrounding enhancement by @ Around in the non-core service tangent plane class, pointing to a self-defined annotation of a non-core service interface by @ indication, and calling ApplicationEventPublisher.
Preferably, when the non-core service is a short message notification,
the custom annotation unit 310 is specifically configured to: the short message notification interface is used for configuring on a core service interface to realize short message sending through the self-defined annotation SendMessage statement;
the interface definition unit 320 is specifically configured to: defining an implementation class Send for sending the short message to realize the function of sending the short message, and taking the implementation class Send as a subscriber for event release;
the event issuing unit 330 is specifically configured to: declare SendMessageAssipect section class, configure the surround enhancement through @ Around, and point to the self-defined annotation SendMessage through @ announcement, call ApplicationEventPublisher.
The service invoking unit 340 is specifically configured to: and calling a short message notification interface through the event-driven model to realize asynchronous processing of the short message notification service and the core service.
Preferably, when the non-core service is a log record,
the custom annotation unit 310 is specifically configured to: a log recording interface is declared through a custom comment ISnsvInfoLog and is used for configuring on a core service interface to realize log recording;
the interface definition unit 320 is specifically configured to: defining a SnsvInfoLog service interface of log records, and taking the SnsvInfoLog service interface as a subscriber of event release;
the event issuing unit 330 is specifically configured to: declaring an SnsvInfAsspect section class, configuring surrounding enhancement through @ Around, pointing to a custom annotation ISnsvInfoLog through @ indication, and calling an ApplicationEventPublisher.
The service invocation unit 340 invokes a logging interface through an event-driven model to implement asynchronous processing of logging services and core services.
According to the technical scheme, the non-core service decoupling device can decouple core service processing and non-core service processing, improves the response speed of a system, enhances the stability and the robustness, is simpler and lighter in program development and use due to service decoupling based on a user-defined annotation mode, is realized by using an event driving mode in the non-core service processing, can enable the program development to be more flexible, and is simpler and more convenient in later maintenance and expansion.
The embodiment of the invention also provides electronic equipment which comprises a memory, a processor and a computer program which is stored on the memory and can run on the processor, wherein the processor executes the program to realize the method.
Embodiments of the present invention further provide a computer program product, which includes a computer program/instruction, and the computer program/instruction implements the steps of the above method when executed by a processor.
An embodiment of the present invention further provides a computer-readable storage medium, in which a computer program for executing the above method is stored.
As shown in fig. 4, the electronic device 600 may further include: communication module 110, input unit 120, audio processor 130, display 160, power supply 170. It is noted that the electronic device 600 does not necessarily include all of the components shown in fig. 4; furthermore, the electronic device 600 may also comprise components not shown in fig. 4, which may be referred to in the prior art.
As shown in fig. 4, the central processor 100, sometimes referred to as a controller or operation control, may include a microprocessor or other processor device and/or logic device, the central processor 100 receiving input and controlling the operation of the various components of the electronic device 600.
The memory 140 may be, for example, one or more of a buffer, a flash memory, a hard drive, a removable media, a volatile memory, a non-volatile memory, or other suitable devices. The information relating to the failure may be stored, and a program for executing the information may be stored. And the central processing unit 100 may execute the program stored in the memory 140 to realize information storage or processing, etc.
The input unit 120 provides input to the cpu 100. The input unit 120 is, for example, a key or a touch input device. The power supply 170 is used to provide power to the electronic device 600. The display 160 is used to display an object to be displayed, such as an image or a character. The display may be, for example, but is not limited to, an LCD display.
The memory 140 may be a solid state memory such as Read Only Memory (ROM), random Access Memory (RAM), a SIM card, or the like. There may also be a memory that holds information even when power is off, can be selectively erased, and is provided with more data, an example of which is sometimes called an EPROM or the like. The memory 140 may also be some other type of device. Memory 140 includes buffer memory 141 (sometimes referred to as a buffer). The memory 140 may include an application/function storage section 142, and the application/function storage section 142 is used to store application programs and function programs or a flow for executing the operation of the electronic device 600 by the central processing unit 100.
The memory 140 may also include a data store 143 for storing data, such as contacts, digital data, pictures, sounds, and/or any other data used by the electronic device. The driver storage portion 144 of the memory 140 may include various drivers of the electronic device for communication functions and/or for performing other functions of the electronic device (e.g., messaging application, address book application, etc.).
The communication module 110 is a transmitter/receiver 110 that transmits and receives signals via an antenna 111. The communication module (transmitter/receiver) 110 is coupled to the central processor 100 to provide an input signal and receive an output signal, which may be the same as in the case of a conventional mobile communication terminal.
Based on different communication technologies, a plurality of communication modules 110, such as a cellular network module, a bluetooth module, and/or a wireless local area network module, may be provided in the same electronic device. The communication module (transmitter/receiver) 110 is also coupled to a speaker 131 and a microphone 132 via an audio processor 130 to provide audio output via the speaker 131 and to receive audio input from the microphone 132 to implement general telecommunication functions. Audio processor 130 may include any suitable buffers, decoders, amplifiers and so forth. In addition, an audio processor 130 is also coupled to the central processor 100, so that recording on the local can be enabled through a microphone 132, and so that sound stored on the local can be played through a speaker 131.
As will be appreciated by one skilled in the art, embodiments of the present invention may be provided as a method, system, or computer program product. Accordingly, the present invention may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present invention may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, and the like) having computer-usable program code embodied therein.
The present invention has been described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each flow and/or block of the flowchart illustrations and/or block diagrams, and combinations of flows and/or blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including instruction means which implement the function specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide steps for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
The principle and the implementation mode of the invention are explained by applying specific embodiments in the invention, and the description of the embodiments is only used for helping to understand the method and the core idea of the invention; meanwhile, for a person skilled in the art, according to the idea of the present invention, there may be variations in the specific embodiments and the application scope, and in summary, the content of the present specification should not be construed as a limitation to the present invention.
Claims (10)
1. A method of uncore traffic decoupling, the method comprising:
declaring a non-core service interface through a custom annotation, wherein the non-core service interface is used for configuring on a core service interface to realize the calling of the non-core service;
defining the non-core service interface to realize the non-core service, and using the non-core service interface as an event subscriber;
when the core service is called, the event of the non-core service is issued according to the custom annotation, and the non-core service interface is called through an event-driven model to realize the asynchronous processing of the non-core service and the core service.
2. The method of decoupling non-core services of claim 1 wherein said issuing events for said non-core services according to said custom annotations when invoking core services comprises:
declaring a non-core service section class, configuring surrounding enhancement by @ Around in the non-core service section class, pointing to a self-defined annotation of a non-core service interface by @ annotation, and calling ApplicationEventPublisher.
3. The method of decoupling non-core traffic according to claim 2, wherein said non-core traffic comprises short message notifications.
4. The non-core traffic decoupling method of claim 3, wherein the method specifically comprises:
the short message notification interface is used for configuring on a core service interface to realize short message sending through the self-defined annotation SendMessage statement;
defining an implementation class Send for sending the short message to realize the function of sending the short message, and taking the implementation class Send as a subscriber for event release;
declare SendMessageAssipect tangent plane class, configure and surround and strengthen through @ Around, and point to self-defined note SendMessage through @ annotation, call ApplicationEventPublisher, publish of short message notification event in tangent plane class processing method;
and calling a short message notification interface through the event-driven model to realize asynchronous processing of the short message notification service and the core service.
5. The method of uncore traffic decoupling according to claim 2, wherein the uncore traffic comprises log records.
6. The uncore traffic decoupling method of claim 5, wherein the method specifically comprises:
a log recording interface is declared through a custom note ISnsvInfoLog and is used for configuring on a core service interface to realize log recording;
defining a SnsvInfoLog service interface of log records, and taking the SnsvInfoLog service interface as a subscriber of event release;
declaring an SnsvInfAsspect section class, configuring surrounding enhancement through @ Around, pointing to a custom annotation ISnsvInfoLog through @ indication, and calling an ApplicationEventPublisher.
And calling a logging interface through the event-driven model to realize asynchronous processing of the logging service and the core service.
7. An apparatus for uncore traffic decoupling, the apparatus comprising:
the system comprises a custom annotation unit, a service interface module and a service interface module, wherein the custom annotation unit is used for declaring a non-core service interface through custom annotation so as to configure the non-core service interface on the core service interface to realize the call of the non-core service;
the interface definition unit is used for defining the non-core service interface to realize the non-core service and taking the non-core service interface as an event subscriber;
the event issuing unit is used for issuing the event of the non-core service according to the user-defined annotation when the core service is called;
and the service calling unit is used for calling the non-core service interface through the event-driven model so as to realize asynchronous processing of the non-core service and the core service.
8. An electronic device comprising a memory, a processor, and a computer program stored on the memory and executable on the processor, wherein the processor implements the steps of the uncore traffic decoupling method of any of claims 1 to 6 when executing the computer program.
9. A computer-readable storage medium, on which a computer program is stored which, when being executed by a processor, carries out the steps of the non-core traffic decoupling method of any one of claims 1 to 6.
10. A computer program product comprising computer programs/instructions, characterized in that the computer programs/instructions, when executed by a processor, implement the steps of the uncore traffic decoupling method of any of claims 1 to 6.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202211046184.6A CN115421766A (en) | 2022-08-30 | 2022-08-30 | Non-core service decoupling method and device |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202211046184.6A CN115421766A (en) | 2022-08-30 | 2022-08-30 | Non-core service decoupling method and device |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN115421766A true CN115421766A (en) | 2022-12-02 |
Family
ID=84201087
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202211046184.6A Pending CN115421766A (en) | 2022-08-30 | 2022-08-30 | Non-core service decoupling method and device |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN115421766A (en) |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN116302163A (en) * | 2022-12-30 | 2023-06-23 | 中国电信股份有限公司 | Target business execution system and method in micro-service |
| CN117692214A (en) * | 2023-12-13 | 2024-03-12 | 天翼云科技有限公司 | Spring-based declaration type FTP transmission method and device |
-
2022
- 2022-08-30 CN CN202211046184.6A patent/CN115421766A/en active Pending
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN116302163A (en) * | 2022-12-30 | 2023-06-23 | 中国电信股份有限公司 | Target business execution system and method in micro-service |
| CN117692214A (en) * | 2023-12-13 | 2024-03-12 | 天翼云科技有限公司 | Spring-based declaration type FTP transmission method and device |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN115421766A (en) | Non-core service decoupling method and device | |
| CN111371695B (en) | Service flow limiting method and device | |
| CN111949614B (en) | Bank system file conversion method and device | |
| CN112882709A (en) | Rendering method, device and equipment based on container engine system and storage medium | |
| CN112866268B (en) | Message processing method and system | |
| CN105094824A (en) | Display method for notification messages on intelligent watch and intelligent watch | |
| CN114338722A (en) | Cloud-edge storage resource management system and method, storage medium and electronic device | |
| CN113434423A (en) | Interface test method and device | |
| CN111063350B (en) | Voice interaction state machine based on task stack and implementation method thereof | |
| CN115982257A (en) | Interface creation method and related device | |
| CN115988058A (en) | A message processing method, device, electronic device, and computer-readable medium | |
| CA3136021A1 (en) | Log storage method and device and computer system | |
| CN114327404A (en) | File processing method and device, electronic equipment and computer readable medium | |
| CN115373869A (en) | Process processing method and device based on AAR and electronic equipment | |
| CN111930690A (en) | File generation method and device | |
| US9384120B2 (en) | Testing of transaction tracking software | |
| CN112087430A (en) | System and method for accessing MCTP (multimedia broadcast multicast service) equipment through SMASH (simple multimedia application service) interface | |
| CN117971760A (en) | Edge computing device framework systems, chips, storage media, and apparatus | |
| CN115510111A (en) | Method and device for releasing activity at fixed time | |
| CN113961194B (en) | Flutter cross-application-based engineering construction method, system, terminal and medium | |
| CN115795537A (en) | Transaction log desensitization method and system | |
| CN113158259B (en) | Blockchain integrity verification method and device | |
| CN114490104B (en) | Information forwarding method, device, equipment and medium in Android system module | |
| CN113268272B (en) | Application delivery method, device and system based on private cloud | |
| CN112272213B (en) | An event registration method and equipment |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |