WO2023010814A1

WO2023010814A1 - Method and apparatus for monitoring dio network request

Info

Publication number: WO2023010814A1
Application number: PCT/CN2022/072070
Authority: WO
Inventors: 郑秀群; 梁少泽
Original assignee: 网宿科技股份有限公司
Priority date: 2021-08-03
Filing date: 2022-01-14
Publication date: 2023-02-09
Also published as: CN113765740B; CN113765740A

Abstract

Disclosed in embodiments of the present application is a method for monitoring a dio network request. The method comprises: embedding an AspectD implementation layer into a Flutter application layer, so that when the Flutter application layer initiates a target network request on the basis of a first implementation interface, the AspectD implementation layer generates a first hook function to perform hooking processing on the first implementation interface to obtain a dio instance; and when the Flutter application layer calls the dio instance, and externally sends the target network request on the basis of a second implementation interface, the AspectD implementation layer generates a second hook function to perform hooking processing on the second implementation interface, and marks a sending timestamp and a response timestamp of the target network request by means of the second hook function.

Description

A method and device for monitoring Dio network requests

cross reference

This application is based on the Chinese patent application with the application number "202110887717.2" and the filing date is August 3, 2021, and claims the priority of the Chinese patent application. The entire content of the Chinese patent application is hereby incorporated by reference. Apply.

technical field

The present application relates to the technical field of the Internet, in particular to a method and device for monitoring Dio network requests.

Background technique

Flutter is a mobile UI framework, using the Flutter framework to quickly build high-quality native user interfaces on IOS and Android systems. In the Flutter application development process, network requests are bound to be used. Dio is a network request plug-in in the Flutter plug-in library, which supports Restful API, FormData, interceptor, request cancellation, cookie management, file upload/download, timeout, custom adapter and other operations, so developers often use Dio network request plug-in Encapsulate network requests.

After a product is developed and delivered to the user, in order to better understand the user's usage and data loading, the developer usually needs to monitor network conditions such as the sending time of network requests and data loading time. However, currently there is no solution for monitoring Flutter Dio network requests.

In view of this, it is necessary to provide a method and device for monitoring Dio network requests to solve the above-mentioned shortcomings.

Contents of the invention

The purpose of this application is to provide a method and device for monitoring Dio network requests, which can monitor Flutter Dio network requests without modifying any code of the application itself.

In order to achieve the above purpose, the present application provides a method for monitoring Dio network requests on the one hand, the method is applied to a client, and the client is constructed with a Flutter application layer and an AspectD implementation layer, and the method includes: when When the Flutter application layer initiates a target network request based on the first implementation interface, the AspectD implementation layer generates a first hook function to hook the first implementation interface to obtain a dio instance; when the Flutter application layer calls the dio instance, and when sending the target network request based on the second implementation interface, the AspectD implementation layer generates a second hook function to perform hook processing on the second implementation interface, and marks it through the second hook function The sending time stamp and response time stamp of the target network request, so as to monitor the sending time and response time of the target network request.

In order to achieve the above purpose, another aspect of the present application also provides a device for monitoring Dio network requests, the device is applied to the client, the client is built with a Flutter application layer, and the device includes: AspectD embedded module , for embedding the AspectD implementation layer in the Flutter application layer; the AspectD implementation layer module is used for generating a first hook function for the first implementation when the Flutter application layer initiates a target network request based on the first implementation interface The interface is hooked to obtain the dio instance, and when the Flutter application layer calls the dio instance and sends the target network request based on the second implementation interface, a second hook function is generated for the second implementation The interface performs hook processing, and marks the sending timestamp and response timestamp of the target network request through the second hook function; the network request monitoring module is configured to monitor all The sending time and response time of the target network request.

In order to achieve the above purpose, another aspect of the present application also provides a device for monitoring Dio network requests, the device includes a memory and a processor, the memory is used to store a computer program, when the computer program is processed When the server is executed, the above-mentioned method for monitoring Dio network requests is implemented.

It can be seen that the technical solution provided by this application first introduces the AspectD implementation layer into the Flutter framework, and then uses the AspectD implementation layer to hook the Flutter application layer to obtain a dio instance. When encapsulating, the AspectD implementation layer can monitor the network conditions such as the sending time of the network request and the loading time of the data, and when the Flutter application layer receives the corresponding response information, the AspectD implementation layer can also monitor the response time of the network request to monitor. In this way, by using the AspectD implementation layer to trace-freely bury the specific methods and specific locations in the underlying library of the Dio network request, the sending time and response of the Dio network request can be obtained without any modification of the Flutter application code. Duration and other data indicators.

Description of drawings

In order to more clearly illustrate the technical solutions in the embodiments of the present application, the drawings that need to be used in the description of the embodiments will be briefly introduced below. Obviously, the drawings in the following description are only some embodiments of the present application. For those skilled in the art, other drawings can also be obtained based on these drawings without creative effort.

Fig. 1 is a schematic diagram of client software architecture in the embodiment of the present application;

Fig. 2 is a flowchart of a method for monitoring a Dio network request in an embodiment of the present application;

FIG. 3 is a schematic diagram of functional modules of a device for monitoring Dio network requests in an embodiment of the present application;

FIG. 4 is a schematic structural diagram of an apparatus for monitoring Dio network requests in an embodiment of the present application.

Detailed ways

In order to make the purpose, technical solution and advantages of the present application clearer, the embodiments of the present application will be further described in detail below in conjunction with the accompanying drawings.

Flutter is a mobile UI framework developed in the Dart language, which can be easily compiled into local codes for different platforms. Therefore, the Flutter framework can be used to quickly build high-quality native user interfaces on IOS and Android systems. Developers are increasingly using the Flutter framework to refactor or create new products.

In the Flutter application development process, network requests are bound to be used, and Dio is a network request plug-in in the Flutter plug-in library. Dio supports Restful API, FormData, interceptor, request cancellation, cookie management, file upload/download, timeout , custom adapter and other operations, so developers often use the Dio network request plug-in to encapsulate network requests under the Flutter framework.

After a product is developed and delivered to the user, in order to better understand the user's usage and data loading, the developer usually needs to monitor network conditions such as the sending time of network requests and data loading time. However, currently there is no solution for monitoring Flutter Dio network requests, which prevents developers from optimizing Flutter applications.

Therefore, how to monitor the Flutter Dio network request to obtain data indicators such as the sending time and response time of the Dio network request has become an urgent problem in this field.

The technical solution provided by this application can solve the above-mentioned deficiencies.

In order to facilitate the understanding of the AspectD content involved in this application, a brief introduction is given below.

AspectD is an AOP (Aspect Oriented Programming, aspect-oriented programming) open source library for Flutter. It is used to solve the problem of AOP for Flutter. It can dynamically and uniformly add functions without modifying the source code of Flutter.

When compiling Flutter, the front end first converts the dart code into the intermediate file app.dill, then converts app.dill into kernel_blob.bin in debug mode, and converts app.dill into framework in release mode. AspectD is to modify app.dill to realize the application of AOP in Flutter. Specifically, AspectD generates an intermediate product by compiling aop.dart, so that the dill file contains both the original project code and the AOP code, and then operates the dill file through the Dill transformation to extract which libraries/classes/methods need to be added. AOP code to add corresponding functions to the Flutter application layer without modifying the Flutter source code.

Please refer to FIG. 1 and FIG. 2 together. FIG. 1 is a schematic diagram of the client software architecture in the embodiment of the present application, and FIG. 2 is a flowchart of a method for monitoring Dio network requests in the embodiment of the present application.

The method for monitoring Dio network requests described in this application is applied to the client, and the client is built with a Flutter application layer, so that the client can run applications developed based on the Flutter framework. At the same time, in the client, the Flutter application layer uses the Dio network request plug-in to encapsulate the network request. It should be pointed out that the specific form of the client includes but is not limited to terminal devices such as mobile phones, tablet computers, and notebook computers. The method for monitoring Dio network requests may include the following steps.

S101: Embedding an AspectD implementation layer in the Flutter application layer, so that when the Flutter application layer initiates a target network request based on the first implementation interface, the AspectD implementation layer generates a first hook function to the first implementation interface Perform hook processing to obtain a dio instance.

In this embodiment, the developer can pre-set the entry point of the AspectD implementation layer for the Flutter application layer according to actual needs (such as monitoring the sending time and response time of network requests), and embed the set AspectD implementation layer into Flutter In the application layer, the AspectD implementation layer is used to monitor Dio network requests.

In one embodiment, embedding the AspectD implementation layer in the Flutter application layer can be implemented in the following manner:

First, inject the AspectD source code into the Flutter framework to create the AspectD implementation layer in the Flutter framework;

Then, add dependencies of the first implementation interface and the second implementation interface in the AspectD implementation layer, so that the AspectD implementation layer performs buried setting for the first implementation interface and the second implementation interface.

In practical applications, developers can first download the Flutter source code and AspectD source code, and then set environment variables such as the flutter image, local flutter source code address, flutter bin directory, dart bin directory, etc., and then switch to the git directory of Flutter, and copy the The git patch file is merged into the Flutter source code project, so that the AspectD source code is injected into the Flutter framework to complete the construction of the AspectD environment. After that, developers can delete the cache files in the original flutter sdk directory (that is, delete the original Flutter compilation tool), rebuild the new Flutter compilation tool, and then use the flutter command to create a new Flutter package (called aspectd_impl), In this way, the developer has completed the work of creating the AspectD implementation layer in the Flutter framework.

After completing the creation of the AspectD implementation layer, developers also need to determine the entry point of the AspectD implementation layer for the Flutter application layer to complete related operations. The following takes the developer's monitoring of Dio network requests as an example to explain how to determine the entry point of the AspectD implementation layer.

In practical applications, the Flutter application layer can use the Dio network request plug-in to initiate a network request. Specifically, the Flutter application layer can use the get or post method in the Dio network request plug-in to initiate a network request. When the Flutter application layer uses the Dio network request plug-in to initiate a target network request, the Dio network request plug-in will create a dio_sendRequest_func interface (called the first implementation interface), and use the above-mentioned first implementation interface to create a dio instance. Finally, the Flutter application layer can pass The dio instance initiates a network request (called a target network request).

When the Flutter application layer initiates a target network request through the above-mentioned dio instance based on the above-mentioned first implementation interface, the Dio network request plug-in can obtain the request header information and request body information of the target network request through the fetch method, and then encapsulate the target network request . After the Dio network request plug-in completes the encapsulation of the target network request, the Dio network request plug-in can send the encapsulated target network request to the external network through the corresponding interface. Specifically, the Dio network request plug-in can create a dio_fetch_func interface (called the second implementation interface), and then use this interface to send a packaged target network request to the outside. Therefore, if the developer needs to monitor the Dio network request, the developer can use the above-mentioned first implementation interface and the above-mentioned second implementation interface as the entry point of the AspectD implementation layer.

In practical applications, after the developer completes the creation of the AspectD implementation layer, he can add AspectD&example dependencies in the aspectd_impl package to associate Flutt-related libraries. AspectD is the AspectD source code downloaded by the developer, and the example is generic Refers to the Flutter APP application that needs to be monitored (such as the Dio network request plug-in). After the developer adds AspectD&example dependencies in the aspectd_impl package, the AspectD implementation layer can obtain the corresponding dependencies from the aspectd_impl package at runtime to implement the corresponding functions. For the Dio network request monitoring function, developers can add the dependencies of the above-mentioned first implementation interface and the above-mentioned second implementation interface into the aspectd_impl package, so that the AspectD implementation layer can implement the above-mentioned first implementation interface and the above-mentioned second implementation interface. Buried point settings.

In one embodiment, when the Flutter application layer initiates a target network request based on the first implementation interface, the AspectD implementation layer may generate a first hook function to hook the above-mentioned first implementation interface to obtain a dio instance. In practical application, since the developer has added the dependencies of the above-mentioned first implementation interface in the aspectd_impl package, the AspectD implementation layer can monitor the first implementation interface (ie, the dio_sendRequest_func interface) during runtime. Specifically, the AspectD implementation layer may use method hook technology (hook) to perform hook processing on the first implementation interface. The AspectD implementation layer may first generate a hook_dio_sendRequest_func function (called the first hook function) in the aspectd_impl package, and associate the first hook function with the first implementation interface.

When the Dio network request plug-in creates the first implementation interface, the system will generate a message notification, which is used to indicate that the first implementation interface has been established, and the system will also pass the message notification to the AspectD implementation layer, so when AspectD After the implementation layer receives the message notification, the AspectD implementation layer can call the first hook function, so as to realize the hooking of the first implementation interface by the first hook function. After the first hook function hooks the first implementation interface, the first hook function can take over the first implementation interface. In this way, when the Flutter application layer creates a dio instance through the above-mentioned first implementation interface, the AspectD implementation layer can obtain the dio instance generated by the Flutter application layer.

In one embodiment, after the AspectD implementation layer obtains the dio instance generated by the Flutter application layer, the AspectD implementation layer can also set an interceptor to monitor the target network request and target response message through the interceptor, wherein the target response message is the same as the target Corresponding to the network request, that is, the target response message is the response information that the responding end feeds back to the client after receiving the target network request. In practical applications, the AspectD implementation layer can create an interceptor class to override the onRequest, onError, and onResponse methods to do some preprocessing before the Flutter application layer sends the request, when the request fails, and before receiving the response. The implementation method can be as follows Code:

dio = new Dio(options);

//add interceptor

dio.interceptors.add(InterceptorsWrapper(onRequest:(RequestOptions options){

print("before request");

// Do some preprocessing before sending the request

return options; //continue

},onResponse:(Response response){

print("before response");

// Do some preprocessing before returning the response data

return response; //continue

},onError:(DioError e){

print("before error");

// Do some preprocessing when the request fails

return e;//continue

}));

Since the first implementation interface and the second implementation interface belong to the inheritance relationship, when the AspectD implementation layer sets the interceptor, the AspectD implementation layer needs to release the first implementation interface, so that the first implementation interface can call the second implementation interface to Outgoing target network requests. Specifically, the AspectD implementation layer can unload the first hook function to cancel the hook between the first hook function and the first call interface. In this way, the first implementation interface will be released, so that the Flutter application layer can continue to pass through the original network The request sending process (that is, calling the second implementation interface through the first implementation interface) sends out the target network request.

It should be pointed out that if the Flutter application layer is configured with a proxy channel, that is, the client needs to send the target network request to the responder through the proxy server, then after the AspectD implementation layer obtains the dio instance generated by the Flutter application layer, the AspectD implementation layer still It is necessary to set a proxy for the dio instance, so that after the target network request is sent from the client, the target network request can first reach the proxy server, and then be transferred to the responder through the proxy server. By setting up a proxy server between the client and the responder, we can introduce a CDN network to improve the response speed of the user's access to the website, thereby solving the problem of slow data loading caused by link problems.

It should be pointed out that the example of monitoring Dio network requests in this application is only illustrative. Based on the idea of this application, those skilled in the art can also monitor other Flutter projects. When monitoring other Flutter projects, those skilled in the art only need to determine the new AspectD implementation layer entry point as needed.

S102: When the Flutter application layer calls the dio instance and sends the target network request based on the second implementation interface, the AspectD implementation layer generates a second hook function to hook the second implementation interface , and mark the sending time stamp and response time stamp of the target network request through the second hook function, so as to monitor the sending time and response time of the target network request.

In this embodiment, after the first implementation interface creates a dio instance, the Flutter application layer can call the above-mentioned dio instance to encapsulate the target network request, and use the second implementation interface (that is, the dio_fetch_func interface) to send the encapsulated target to the outside network request. In practical application, since the developer has added the dependencies of the above-mentioned second implementation interface in the aspectd_impl package, the AspectD implementation layer can monitor the second implementation interface during runtime. Specifically, the AspectD implementation layer may use a method hook technology (hook) to perform hook processing on the second implementation interface. The AspectD implementation layer may first generate a hook_fetch_func function (called a second hook function) in the aspectd_impl package, and associate the second hook function with the second implementation interface.

When the Dio network request plug-in creates the second implementation interface, the system will generate a message notification, which is used to indicate that the second implementation interface has been established, and the system will also pass the message notification to the AspectD implementation layer, so when AspectD After the implementation layer receives the message notification, the AspectD implementation layer can call the second hook function, so as to realize the hooking of the second implementation interface by the second hook function. After the second hook function hooks the second implementation interface, the second hook function can take over the second implementation interface. In this way, when the Flutter application layer sends out the target network request through the second implementation interface, the AspectD implementation layer can use the second hook function to mark the sending timestamp of the target network request. Correspondingly, when the Flutter application layer receives the target response message fed back by the responder through the second implementation interface, the AspectD implementation layer can use the second hook function to mark the response timestamp of the target network request. After marking the sending time stamp and response time stamp of the target network request, the AspectD implementation layer can report the above time stamp to the monitoring terminal, so that developers can monitor the sending time and response time of the target network request.

In one embodiment, the AspectD implementation layer marking the sending timestamp of the target network request through the second hook function includes the following steps:

First, before the Flutter application layer calls the dio instance to send the target network request, the AspectD implementation layer marks the first timestamp through the second hook function;

Then, after the Flutter application layer invokes the dio instance to complete sending the target network request, the AspectD implementation layer marks the second timestamp through the second hook function.

In practical applications, when the Dio network request plug-in completes the encapsulation of the target network request, but has not yet sent the request header information and request body information of the target network request (that is, before the Flutter application layer calls the dio instance to send the target network request), AspectD implements The layer may mark the first timestamp through the second hook function. When the Dio network request plug-in uses the second implementation interface to send the encapsulated target network request (that is, after the Flutter application layer calls the dio instance to complete the sending of the target network request), the AspectD implementation layer can mark the second time through the second hook function stamp. The first timestamp and the second timestamp are the sending timestamps of the target network request.

After the AspectD implementation layer reports the above-mentioned first timestamp and the above-mentioned second timestamp to the monitoring terminal, the developer can calculate the sending time of the target network request based on the difference between the first timestamp and the second timestamp , and then determine whether the Flutter application or network needs to be optimized.

In one embodiment, the AspectD implementation layer marking the response timestamp of the target network request through the second hook function includes the following steps:

First, before the second implementation interface receives the target response message, the AspectD implementation layer marks the third timestamp through the second hook function;

After the second implementation interface receives the target response message, the AspectD implementation layer marks the fourth timestamp through the second hook function.

In practical applications, when the target network request is sent to the external network, the source station (that is, the responder) to which the target network request points will receive the target network request. When the responder receives the target network request, the responder will feed back the response information (target response message) to the client. Based on the characteristics of the Dio network request plug-in, the target response message will be received by the dio_fetch_func interface, that is, the target response message will be received by Passed to the second implementation interface. Therefore, the AspectD implementation layer can use the second hook function to monitor the response time of the target network request. Specifically, the second hook function may mark a time point (marked as a third time stamp) before the second implementation interface receives the target response message, and mark a time point (marked as a third time stamp) after the second implementation interface receives the target response message (marked as is the fourth timestamp). The aforementioned third timestamp and the aforementioned fourth timestamp are response timestamps of the target network request.

Correspondingly, after the AspectD implementation layer reports the third timestamp and the fourth timestamp to the monitoring terminal, the developer can calculate the target network request based on the difference between the third timestamp and the fourth timestamp Response time, and then determine whether to optimize the network or the response end.

In one embodiment, the interceptor monitors the target network request and target response message in the following manner:

First, intercept the second implementation interface to obtain the target network request and target response message;

Then, parse the target network request and the target response message to obtain the request header information and request body information of the target network request, and the response header information and response body information of the target response message.

In practical applications, when the AspectD implementation layer creates an interceptor class to cover the onRequest, onError, and onResponse methods, the interceptor can intercept the second implementation interface, so that when the Dio network request plug-in uses the second implementation interface to send out the package When there is a good target network request, the interceptor can obtain the above-mentioned encapsulated target network request. After the interceptor obtains the above-mentioned target network request, the interceptor can analyze the target network request, so as to obtain request header information and request body information of the target network request. Furthermore, when the interceptor obtains the request header information and request body information of the target network request, the interceptor can report the above request header information and request body information to the monitoring end, so that the developer can monitor the target network request Analysis to monitor target network requests. For example, the interceptor can analyze the target network request to obtain the cookie information, token information, host information, etc. stored in the request header information, as well as the post parameters and parameter data stored in the request body information, and then intercept The controller can report the obtained above information to the monitoring terminal. After the interceptor finishes reporting the request header information and request body information of the target network request, the interceptor will return the above target network request to the Flutter application layer, so that the Flutter application layer can continue to send the target network request outward.

Correspondingly, when the second implementation interface receives the target response message fed back by the responder, the interceptor can also obtain the above target response message, and then, the interceptor can analyze the above target response message to obtain the response of the target response message Header information and response body information. Furthermore, after the interceptor obtains the response header information and response body information of the target response message, the interceptor can report the above response header information and response body information to the monitoring terminal, so that the developer can monitor the target response message Analysis to realize the monitoring of target response messages.

It should be pointed out that after the interceptor finishes reporting the response header information and response body information of the target response message, the interceptor can return the above target response message to the Flutter application layer, so that the Flutter application layer can The terminal displays the target response message normally.

Please refer to Figure 3, the present application also provides a device for monitoring Dio network requests, the device is applied to the client, the client is built with a Flutter application layer, the device includes:

The AspectD embedding module is used to embed the AspectD implementation layer in the Flutter application layer;

The AspectD implementation layer module is used to generate a first hook function to hook the first implementation interface to obtain a dio instance when the Flutter application layer initiates a target network request based on the first implementation interface, and when the Flutter When the application layer calls the dio instance and sends the target network request based on the second implementation interface, a second hook function is generated to perform hook processing on the second implementation interface, and the second hook function is used to mark the The sending timestamp and response timestamp of the target network request;

A network request monitoring module, configured to monitor the sending time and response time of the target network request based on the sending time stamp and the response time stamp.

In one embodiment, the AspectD embedding module is also used to inject the AspectD source code into the Flutter framework to create the AspectD implementation layer in the Flutter framework;

The AspectD implementation layer module is further configured to add dependencies of the first implementation interface and the second implementation interface, so as to perform buried setting for the first implementation interface and the second implementation interface.

In one embodiment, the device also includes:

An interceptor setting module, configured to set an interceptor to monitor the target network request and target response message, wherein the target response message corresponds to the target network request;

An interface release module, configured to release the first implementation interface, so that the first implementation interface invokes the second implementation interface to send the target network request.

In one embodiment, marking the sending timestamp of the target network request through the second hook function includes:

Before the Flutter application layer invokes the dio instance to send the target network request, the first timestamp is marked by the second hook function;

After the Flutter application layer calls the dio instance to complete sending the target network request, the second timestamp is marked by the second hook function.

In one embodiment, marking the response timestamp of the target network request through the second hook function includes:

Before the second implementation interface receives the target response message, mark a third timestamp through the second hook function;

After the second implementation interface receives the target response message, mark the fourth timestamp through the second hook function.

In one embodiment, monitoring the sending duration and response duration of the target network request includes:

calculating the sending duration of the target network request based on the first timestamp and the second timestamp;

Based on the third time stamp and the fourth time stamp, calculate the response duration of the target network request.

In one embodiment, monitoring the target network request and target response messages includes:

intercepting the second implementation interface to obtain the target network request and the target response message;

Parsing the target network request and the target response message to obtain request header information and request body information of the target network request, and response header information and response body information of the target response message.

Please refer to Figure 4, the present application also provides a device for monitoring Dio network requests, the device includes a memory and a processor, the memory is used to store a computer program, when the computer program is executed by the processor , the method for monitoring Dio network requests as described above can be implemented. Specifically, at the hardware level, the device may include a processor, an internal bus, and a memory. The memory may include internal memory and non-volatile memory. The processor reads the corresponding computer program from the non-volatile memory into the memory and runs it. Those of ordinary skill in the art can understand that the structure shown in FIG. 4 is only a schematic diagram, which does not limit the structure of the above-mentioned device. For example, the device may also include more or fewer components than those shown in FIG. 4 , for example, may also include other processing hardware, such as a GPU (Graphics Processing Unit, image processor), or an external communication port. Of course, in addition to the software implementation, the present application does not exclude other implementations, such as logic devices or a combination of software and hardware.

In this embodiment, the processor may include a central processing unit (CPU) or a graphics processing unit (GPU), and of course it may also include other single-chip microcomputers with logic processing capabilities, logic gate circuits, integrated circuits, etc., or other appropriate combination. The memory described in this embodiment may be a memory device for storing information. In a digital system, a device that can store binary data can be a memory; in an integrated circuit, a circuit with a storage function that does not have a physical form can also be a memory, such as RAM, FIFO, etc.; in a system, a storage with a physical form A device can also be called a memory, etc. During implementation, the storage may also be implemented in the form of cloud storage, and the specific implementation manner is not limited in this specification.

It should be noted that, the specific implementation of the device for monitoring Dio network requests in this specification can refer to the description of the method embodiment, and details are not repeated here.

It can be seen that the technical solution provided by this application first introduces the AspectD implementation layer into the Flutter framework, and then uses the AspectD implementation layer to hook the Flutter application layer to obtain a dio instance. When encapsulating, the AspectD implementation layer can monitor the network conditions such as the sending time of the network request and the loading time of the data, and when the Flutter application layer receives the corresponding response information, the AspectD implementation layer can also monitor the response time of the network request to monitor. In this way, by using the AspectD implementation layer to trace-freely bury the specific methods and specific locations in the underlying library of the Dio network request, the sending time and response of the Dio network request can be obtained without any modification of the Flutter application code. Duration and other data indicators. At the same time, by setting the interceptor, the AspectD implementation layer can also monitor the request header information and request body information of the network request, as well as the response header information and response body information of the response information, so that developers can according to the monitoring situation, Targeted optimization of Flutter applications.

Through the above description of the embodiments, those skilled in the art can clearly understand that each embodiment can be implemented by means of software plus a necessary general-purpose hardware platform, and of course can also be implemented by hardware. Based on this understanding, the essence of the above technical solution or the part that contributes to the prior art can be embodied in the form of software products, and the computer software products can be stored in computer-readable storage media, such as ROM/RAM, magnetic discs, optical discs, etc., including several instructions to make a computer device (which may be a personal computer, server, or network device, etc.) execute the methods described in various embodiments or some parts of the embodiments.

The above descriptions are only preferred embodiments of the application, and are not intended to limit the application. Any modifications, equivalent replacements, improvements, etc. made within the spirit and principles of the application shall be included in the protection of the application. within range.

Claims

A kind of method that Dio network request is monitored, and described method is applied in client, and described client is constructed with Flutter application layer, and described method comprises:

Embedding the AspectD implementation layer in the Flutter application layer, so that when the Flutter application layer initiates a target network request based on the first implementation interface, the AspectD implementation layer generates a first hook function to hook the first implementation interface Process to get the dio instance;

When the Flutter application layer calls the dio instance and sends the target network request based on the second implementation interface, the AspectD implementation layer generates a second hook function to hook the second implementation interface, and The sending time stamp and response time stamp of the target network request are marked by the second hook function, so as to monitor the sending time and response time of the target network request.
The method according to claim 1, wherein said embedding AspectD implementation layer in said Flutter application layer comprises:

Inject the AspectD source code into the Flutter framework to create the AspectD implementation layer in the Flutter framework;

Adding dependencies of the first implementation interface and the second implementation interface in the AspectD implementation layer, so that the AspectD implementation layer performs buried setting for the first implementation interface and the second implementation interface .
The method according to claim 1, wherein, after the AspectD implementation layer obtains the dio instance, the method further comprises:

setting an interceptor to monitor the target network request and target response message, wherein the target response message corresponds to the target network request;

The first implementation interface is released, so that the first implementation interface invokes the second implementation interface to send the target network request.
The method according to claim 1, wherein the AspectD implementation layer marks the sending timestamp of the target network request through the second hook function, comprising:

Before the Flutter application layer invokes the dio instance to send the target network request, the AspectD implementation layer marks the first timestamp through the second hook function;

After the Flutter application layer invokes the dio instance to complete sending the target network request, the AspectD implementation layer marks a second timestamp through the second hook function.
The method according to claim 4, wherein the AspectD implementation layer marks the response timestamp of the target network request through the second hook function, comprising:

Before the second implementation interface receives the target response message, the AspectD implementation layer marks a third timestamp through the second hook function;

After the second implementation interface receives the target response message, the AspectD implementation layer marks a fourth timestamp through the second hook function.
The method according to claim 5, wherein the monitoring the sending duration and response duration of the target network request comprises:

calculating the sending duration of the target network request based on the first timestamp and the second timestamp;

Based on the third time stamp and the fourth time stamp, calculate the response duration of the target network request.
The method according to claim 3, wherein said monitoring said target network request and target response messages comprises:

intercepting the second implementation interface to obtain the target network request and the target response message;

Parsing the target network request and the target response message to obtain request header information and request body information of the target network request, and response header information and response body information of the target response message.
A kind of device that Dio network request is monitored, and described device is applied in client, and described client is built with Flutter application layer, and described device comprises:

The AspectD embedding module is used to embed the AspectD implementation layer in the Flutter application layer;

The AspectD implementation layer module is used to generate a first hook function to hook the first implementation interface to obtain a dio instance when the Flutter application layer initiates a target network request based on the first implementation interface, and when the Flutter When the application layer calls the dio instance and sends the target network request based on the second implementation interface, a second hook function is generated to perform hook processing on the second implementation interface, and the second hook function is used to mark the The sending timestamp and response timestamp of the target network request;

A network request monitoring module, configured to monitor the sending time and response time of the target network request based on the sending time stamp and the response time stamp.
The device according to claim 8, wherein the AspectD embedding module is also used to inject the AspectD source code into the Flutter framework to create the AspectD implementation layer in the Flutter framework;

The AspectD implementation layer module is further configured to add dependencies of the first implementation interface and the second implementation interface, so as to perform buried setting for the first implementation interface and the second implementation interface.
The device according to claim 8, wherein the device further comprises:

An interceptor setting module, configured to set an interceptor to monitor the target network request and target response message, wherein the target response message corresponds to the target network request;

An interface release module, configured to release the first implementation interface, so that the first implementation interface invokes the second implementation interface to send the target network request.
A device for monitoring a Dio network request, the device includes a memory and a processor, the memory is used to store a computer program, and when the computer program is executed by the processor, the implementation of claims 1 to 7 A method as claimed in any one of the claims.