CN105824665B - Method and system for weaving aspects in JavaScript programs - Google Patents

Abstract

The invention discloses an aspect weaving method and system in a JavaScript program. Among them, the method includes: creating a multi-threaded execution environment; opening a thread, executing the notification type method in the AOP object, and judging whether the pre-declared target connection point is loaded; if loaded, opening another thread, and saving the target connection point with a temporary variable , write the temporary variable and the received notification method of the target connection point into the target connection point according to the notification type method, and complete the aspect weaving; if not loaded, continue to judge whether the target connection point is loaded. The present invention first simulates a multi-threaded running environment in a single-threaded JavaScript running environment, and then uses an object monitoring thread to monitor the loading of an object in the multi-threaded environment, and weaves the object immediately after it is loaded, avoiding the present In the prior art, the declaration of the aspect must be executed after the target connection point is loaded into the object, thus solving the problem of failure in weaving the aspect of the target connection point.

Description

Method and system for weaving aspects in JavaScript programs

technical field

The invention relates to the field of computer technology, in particular to a method and system for weaving aspects in a JavaScript program.

Background technique

JavaScript is a scripting language specially designed for web page interaction, and is widely used in almost all web applications. With the increasing of Web application technology, the complexity of the program is getting higher and higher, which makes the development and maintenance of the JavaScript program in it more and more difficult. As an important part of the Web, the importance of JavaScript is self-evident. People usually use OOP (Object Oriented Programming, object-oriented programming) to simplify the development and maintenance process of JavaScript, but due to its limitations, a large number of redundant codes with the same functions also increase the development and maintenance costs of JavaScript.

AOP (Aspect Oriented Programming, Aspect-Oriented Programming) encapsulates cross-cutting concerns in aspects (Aspect), thereby realizing unified management and maintenance of cross-cutting concerns, thereby reducing the complexity of system development. An aspect includes two parts: Pointcut and Advice. The pointcut defines a set of connection points (JointPoint) when a certain advice should be executed, and the connection point represents a program during execution. a foreseeable point. After weaving an aspect to the target join point, when it executes, the advice in the weaving aspect will be executed accordingly. Therefore, it is of great significance to apply AOP to the development and maintenance of JavaScript.

At present, many scholars have implemented lightweight aspect-oriented JavaScript frameworks, and AspectJS is one of the more mature and comprehensive ones. AspectJS is an aspect-oriented JavaScript component that has full control over method call interception. Based on the dynamic nature of the JavaScript language, it uses method call interception (MCI) technology to execute other methods before and after calling the target function, which is transparent to the caller. The method of aggregate function call is the basic principle of AspectJS to realize AOP. AspectJS provides full control and sophisticated management of intercepted method calls, making aspect-oriented JavaScript programming easy and simple. However, the framework's declaration of the aspect must be after the declaration of the join point target, otherwise the weaving machine will not be able to find the target join point due to the execution sequence of the JavaScript program, resulting in the failure of aspect weaving.

AOJS is an aspect-oriented JavaScript framework different from AspectJS. The biggest difference is that AOJS uses XML files to define aspects, and then implements aspect weaving through a proxy server. The biggest disadvantage of the previous aspect-oriented JavaScript frameworks is that the aspects are not completely separated from the source code. The result of this is that when the aspects are woven into the source code, it may cause some program reliability problems. However, AOJS completely separates aspects from source code, and weaves aspects into source code at runtime through a proxy server, eliminating the intrusion of defining aspects to source code. However, because AOJS completely abandons the advantages of the language features of JavaScript itself, and uses external programs to modify JavaScript programs in Web applications according to predefined XML files, this makes it difficult to apply AOP to Web projects, and it is difficult to test. At the same time, the proxy server required by AOJS also increases the cost of Web applications.

AspectScript is a mature aspect-oriented JavaScript framework with high-level programming and dynamism at its core. According to the dynamic nature of the JavaScript language, AspectScript supports dynamic scheduling of aspects. At the same time, because AspectScript makes full use of the advantages of high-level programming, it makes the definition of pointcuts and aspects more precise, and combined with scope strategies, AspectScript provides precise control over aspects. Finally, AspectScript not only supports implicit join points, but also provides the possibility to accurately define user-defined join points, thus providing rich extension possibilities for the framework. Compared with AspectJS, AspectScript is more comprehensive and rich in functions, but it still has the same disadvantages as AspectJS, that is, the target connection point and the declaration of the aspect have a strict execution sequence, which in some cases will cause the target connection point. Entry failed.

The above three aspect-oriented JavaScript programming implementations are mainly implemented in two ways: static and dynamic. Since JavaScript is an interpreted language and does not need to be compiled by a compiler, static weaving requires an external program to modify the source file according to the pre-defined aspect file. AOJS is aspect-oriented JavaScript programming realized by this method. The framework defines aspects in XML files, and then uses other programs to parse these XML files, and weaves the aspects defined in them into JavaScript programs. However, this method completely abandons the dynamic characteristics of the JavaScript language, and the implementation is also very complicated. Therefore, most implementations use the language characteristics of JavaScript to dynamically complete aspect weaving. However, implementations like AspectJS and AspectScript do not fully consider the order of connection point loading and aspect weaving, and the implementation of aspect-oriented JavaScript programming is not comprehensive enough, which may cause the target connection point to weave aspects. fail.

Contents of the invention

The embodiment of the present invention provides a method and system for weaving aspects in a JavaScript program, which solves the technical problem in the prior art that target connection points and aspect declarations must have a strict order of execution, and realizes the avoidance of target connection points. The technical effect of failure in weaving.

The embodiment of the present invention provides a method for weaving aspects in a JavaScript program, including:

Create a multi-threaded execution environment;

Open a thread, execute the notification type method in the AOP object, and judge whether the pre-declared target connection point is loaded;

If loading, open another thread, save the target connection point with a temporary variable, write the temporary variable and the received notification method of the target connection point into the target connection point according to the notification type method, and complete the aspect Weave into;

If not loaded, continue to determine whether the target connection point is loaded.

Further, said opening a thread, executing the notification type method in the AOP object, and judging whether the pre-declared target connection point is loaded, specifically includes:

Create an AOP object;

defining at least 3 notification type methods in the AOP object;

storing the target connection point and its notification method in each notification type method;

In each of the notification type methods, determine whether the target connection point is loaded;

If it is loaded, start another thread, and save the target connection point with a temporary variable, specifically including:

If the target connection point is loaded in any one of the notification type methods, start another thread, and use the temporary variable to save the target connection point.

Further, the judging whether the target connection point is loaded specifically includes:

judging whether the target connection point is loaded into a corresponding execution environment;

If yes, it indicates that the target connection point is loaded.

Further, the notification type method includes: pre-notification, post-notification and surrounding notification.

The aspect weaving system in the JavaScript program provided by the present invention includes:

A multi-thread creation module for creating a multi-thread execution environment;

The judging module is used to start a thread, execute the notification type method in the AOP object, and judge whether the pre-declared target connection point is loaded;

An aspect weaving module is used to open another thread if the judgment result of the judging module is loading, save the target connection point with a temporary variable, and connect the temporary variable to the received target according to the notification type method The notification method of the point is written to the target connection point to complete the aspect weaving.

Further, the judging module specifically includes:

AOP object creation unit, used to create AOP objects;

a notification type creation unit, configured to define at least three methods of the notification type in the AOP object;

An information receiving unit, configured to store the target connection point and its notification method in each notification type method;

A judging execution unit, configured to judge whether the target connection point is loaded in each notification type method;

The aspect weaving module is specifically used to start another thread and use the temporary variable to save the target if the judgment result of the judgment execution unit is that the target connection point is loaded in any one of the notification type methods The connection point writes the temporary variable and the received notification method of the target connection point into the target connection point according to the notification type method to complete aspect weaving.

Further, the judgment execution unit is specifically configured to respectively judge whether the target connection point is loaded into the corresponding execution environment in each of the notification type methods;

If yes, it means that the target connection point is loaded in this notification type.

Further, the notification type method includes: pre-notification, post-notification and surrounding notification.

One or more technical solutions provided in the embodiments of the present invention have at least the following technical effects or advantages:

First simulate a multi-threaded running environment in a single-threaded JavaScript running environment, and then use an object monitoring thread to monitor the loading of the object in the multi-threaded environment, and weave the object immediately after it is loaded, avoiding the existing technology The declaration of the aspect must be executed after the target connection point is loaded into the object, thus solving the problem that the target connection point weaves the aspect failure.

Description of drawings

FIG. 1 is a flowchart of an aspect weaving method in a JavaScript program provided by Embodiment 1 of the present invention;

FIG. 2 is a block diagram of a system for weaving aspects in a JavaScript program provided by Embodiment 2 of the present invention.

Detailed ways

The embodiment of the present invention provides a method and system for weaving aspects in a JavaScript program, which solves the technical problem in the prior art that target connection points and aspect declarations must have a strict order of execution, and realizes the avoidance of target connection points. The technical effect of failure in weaving.

The technical solution in the embodiment of the present invention is to solve the above-mentioned technical problems, and the general idea is as follows:

First simulate a multi-threaded running environment in a single-threaded JavaScript running environment, and then use an object monitoring thread to monitor the loading of the object in the multi-threaded environment, and weave the object immediately after it is loaded, avoiding the existing technology The declaration of the aspect must be executed after the target connection point is loaded into the object, thus solving the problem that the target connection point weaves the aspect failure.

In order to better understand the above technical solution, the above technical solution will be described in detail below in conjunction with the accompanying drawings and specific implementation methods.

Embodiment one

Referring to Fig. 1, the method for weaving aspects in the JavaScript program provided by the embodiment of the present invention includes:

Step S110: creating a multi-thread execution environment;

To illustrate this step, first import the Concurrent.Thread.js library, and prepare to create a monitoring thread for the notification call of each AOP object, and pass in the connection point and notification method to the notification call.

Step S120: start a thread, execute the notification type method in the AOP object, and judge whether the pre-declared target connection point is loaded;

Step S130: If loaded, start another thread, save the target connection point with a temporary variable, write the temporary variable and the received notification method of the target connection point into the target connection point according to the notification type method, and complete the aspect weaving;

If not loaded, continue to judge whether the target connection point is loaded.

Specifically, step S120 is specifically described, including:

Create an AOP object;

In this embodiment, the default notification methods of all connection points are properties of window, and the basic code for creating AOP objects of various notifications is implemented as follows:

Define at least 3 notification type methods in the AOP object;

In this embodiment, the notification type methods include: pre-notification, post-notification and surrounding notification, namely before, after and around.

Store the target connection point and its notification method in each notification type method;

In each notification type method, determine whether the target connection point is loaded;

In this embodiment, judging whether the target connection point is loaded specifically includes:

Determine whether the target join point is loaded into the corresponding execution environment;

If so, the target join point is loaded.

Specifically, when the target connection point is loaded on the window object, the aspect weaver weaver is called. If it has not been loaded, continue monitoring in the current thread. The code to declare an aspect is as follows:

Weaver saves the connection point target in a temp variable, then encapsulates the notification function and temp into the aspect method according to the notification type, and finally assigns the aspect method to the connection point target to complete the aspect weaving.

The basic functions of the weaver method are implemented as follows:

In this case, if loading in step S130, start another thread, and save the target connection point with a temporary variable, specifically including:

If the target connection point is loaded in any advice type method, start another thread and save the target connection point with a temporary variable.

Embodiment two

Referring to Fig. 2, the aspect weaving system in the JavaScript program provided by the embodiment of the present invention includes:

A multi-thread creation module 100, configured to create a multi-thread execution environment;

In this embodiment, the multi-thread creation module 100 is specifically used to introduce the Concurrent.Thread.js library, and prepare to create a monitoring thread for the notification call of each AOP object, and call the incoming connection point and notification method for the notification call.

The judging module 200 is used to open a thread, execute the notification type method in the AOP object, and judge whether the pre-declared target connection point is loaded;

Aspect weaving module 300 is used to open another thread if the judgment result of judging module 200 is loading, save the target connection point with a temporary variable, write the temporary variable and the notification method of the received target connection point according to the notification type method Target join point to complete aspect weaving.

In this embodiment, the judging module 200 specifically includes:

AOP object creation unit, used to create AOP objects;

A notification type creation unit is used to define at least 3 notification type methods in the AOP object;

In this embodiment, the notification type methods include: pre-notification, post-notification and surrounding notification, namely before, after and around.

The information receiving unit is used to store the target connection point and its notification method in each notification type method;

A judging execution unit is used to judge whether the target connection point is loaded in each notification type method;

In this embodiment, the judging execution unit is specifically used to judge whether the target connection point is loaded into the corresponding execution environment in each notification type method;

If so, the target join point is loaded in that advice type.

In this case, the aspect weaving module 300 is specifically used to start another thread if the judging result of the execution unit is that the target connection point is loaded in any notification type method, save the target connection point with a temporary variable, and follow the notification The type method writes the temporary variable and the received notification method of the target connection point into the target connection point to complete aspect weaving.

【Technical effect】

First simulate a multi-threaded running environment in a single-threaded JavaScript running environment, and then use an object monitoring thread to monitor the loading of the object in the multi-threaded environment, and weave the object immediately after it is loaded, avoiding the existing technology The declaration of the aspect must be executed after the target connection point is loaded into the object, thus solving the problem that the target connection point weaves the aspect failure.

Those skilled in the art should understand that the embodiments of the present invention may be provided as methods, systems, or computer program products. Accordingly, the present invention can 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, etc.) having computer-usable program code embodied therein.

The present invention is 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 should be understood that each process and/or block in the flowchart and/or block diagram, and a combination of processes and/or blocks in the flowchart and/or block diagram can be realized by computer program instructions. These computer program instructions may be provided to a general purpose computer, special purpose computer, embedded processor, or processor of other programmable data processing equipment to produce a machine such that the instructions executed by the processor of the computer or other programmable data processing equipment produce a An apparatus for realizing the functions specified in one or more procedures of the flowchart and/or one or more blocks of the block diagram.

These computer program instructions may also be stored in a computer-readable memory capable of directing a computer or other programmable data processing apparatus to operate in a specific manner, such that the instructions stored in the computer-readable memory produce an article of manufacture comprising instruction means, the instructions The device realizes the function specified in one or more procedures of the flowchart and/or one or more blocks of the block diagram.

These computer program instructions can also be loaded onto a computer or other programmable data processing device, causing a series of operational steps to be performed on the computer or other programmable device to produce a computer-implemented process, thereby The instructions provide steps for implementing the functions specified in the flow chart or blocks of the flowchart and/or the block or blocks of the block diagrams.

While preferred embodiments of the invention have been described, additional changes and modifications to these embodiments can be made by those skilled in the art once the basic inventive concept is appreciated. Therefore, it is intended that the appended claims be construed to cover the preferred embodiment as well as all changes and modifications which fall within the scope of the invention.

Obviously, those skilled in the art can make various changes and modifications to the present invention without departing from the spirit and scope of the present invention. Thus, if these modifications and variations of the present invention fall within the scope of the claims of the present invention and their equivalent technologies, the present invention also intends to include these modifications and variations.

Claims (6)

1. A method for weaving aspects in a JavaScript program, comprising: Create a multi-threaded execution environment; Open a thread, execute the notification type method in the AOP object, and judge whether the pre-declared target connection point is loaded; If loading, open another thread, save the target connection point with a temporary variable, write the temporary variable and the received notification method of the target connection point into the target connection point according to the notification type method, and complete the aspect Weave into; If not loaded, continue to determine whether the target connection point is loaded; First simulate a multi-threaded running environment in a single-threaded JavaScript running environment, and then use an object monitoring thread to monitor the loading of the object in the multi-threaded environment, and weave aspects into it immediately after the object is loaded; Said opening a thread, executing the notification type method in the AOP object, and judging whether the pre-declared target connection point is loaded, specifically includes: Create an AOP object; defining at least 3 notification type methods in the AOP object; storing the target connection point and its notification method in each notification type method; In each of the notification type methods, determine whether the target connection point is loaded; If it is loaded, start another thread, and save the target connection point with a temporary variable, specifically including: If the target connection point is loaded in any one of the notification type methods, start another thread, and use the temporary variable to save the target connection point. 2. The method according to claim 1, wherein the judging whether the target connection point is loaded specifically comprises: judging whether the target connection point is loaded into a corresponding execution environment; If yes, it indicates that the target connection point is loaded. 3. The method according to claim 1 or 2, wherein the notification type methods include: pre-notification, post-notification and surrounding notification. 4. An aspect weaving system in a JavaScript program, comprising: A multi-thread creation module for creating a multi-thread execution environment; The judging module is used to start a thread, execute the notification type method in the AOP object, and judge whether the pre-declared target connection point is loaded; An aspect weaving module is used to open another thread if the judgment result of the judging module is loading, save the target connection point with a temporary variable, and connect the temporary variable to the received target according to the notification type method The notification method of the point is written into the target connection point to complete the aspect weaving; First simulate a multi-threaded running environment in a single-threaded JavaScript running environment, and then use an object monitoring thread to monitor the loading of the object in the multi-threaded environment, and weave aspects into it immediately after the object is loaded; The judgment module specifically includes: AOP object creation unit, used to create AOP objects; a notification type creation unit, configured to define at least three methods of the notification type in the AOP object; An information receiving unit, configured to store the target connection point and its notification method in each notification type method; A judging execution unit, configured to judge whether the target connection point is loaded in each notification type method; The aspect weaving module is specifically used to start another thread and use the temporary variable to save the target if the judgment result of the judgment execution unit is that the target connection point is loaded in any one of the notification type methods The connection point writes the temporary variable and the received notification method of the target connection point into the target connection point according to the notification type method to complete aspect weaving. 5. The system according to claim 4, wherein the judgment execution unit is specifically configured to respectively judge whether the target connection point is loaded into the corresponding execution environment in each of the notification type methods; If yes, it means that the target connection point is loaded in this notification type. 6. The system according to claim 4 or 5, wherein the notification type methods include: pre-notification, post-notification and surrounding notification.