JP2007213487A - Aspect generation method and apparatus - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To facilitate generation of an aspect to be included in an assumed point in a program. <P>SOLUTION: An aspect generation apparatus is equipped with: a class information analysis means for analyzing a class structure, acquiring a name of the class, a name of a method, and a signature used in each class, and generating candidates for the name of the class, name of the method, and the signature to be defined in an aspect to be generated; an advise analysis means for analyzing a data structure of candidates for advice given by the aspect to be cut out as shared processing; a management means for displaying on a user interface screen a class figure which clearly shows the name of the class, the name of the method, and the signature in use in a program to be developed and the candidates for the advice analyzed by the advice analysis means; and an aspect generating means for allowing the user to select the displayed candidates for the advice and candidates for the name of the class, the name of the method, and the signature and generating the aspect. <P>COPYRIGHT: (C)2007,JPO&INPIT

Description

  The present invention relates to an aspect generation method and apparatus in aspect-oriented programming.

Currently, aspect-oriented programming, which is a new concept in application development, is drawing attention.
Aspect orientation refers to extracting functions that are used in common among modules installed in a program and automatically incorporating them into the program later. Examples of aspects include logs and transaction management. In addition, since aspect orientation is not a concept that contradicts object orientation, these two can be used in combination.
Here, aspect-oriented programming will be described using a log as an example.
Conventionally, when a log is output, the log is output by calling a code for calling a log component from the program. In such cases, it is common to write code that calls the log component in the module that the developer is in charge of, but the accuracy of log output varies depending on the skill of each developer, so the entire system is homogeneous. It was difficult to output a log with a large amount of information.
By using aspect-oriented programming, the log output function can be cut out as an aspect and automatically incorporated into the program of the entire system, so that a log with a uniform amount of information can be output throughout the system. It becomes possible to do.
By using aspect-oriented programming in this way, it is possible to cut out functions to be used across modules and embed them later by setting.

An aspect is composed of an advice that describes the processing to be performed by the aspect and a pointcut that specifies where the advice is embedded.
There are three types of advice: before advice executed before executing the process of the embedding destination, after advice executed after, and around advice executed so as to wrap around the process.
There are also advice for methods and field access.
In pointcut, it is possible to specify by specifying which method of a certain class is called, which field is accessed, whether a certain class is instantiated, etc. as a point.
Pointcuts can be used to specify multiple points at once by using a wildcard (*) in addition to specifying class names and method names directly.

  In order to realize aspect-oriented programming, it is necessary to define how aspects are defined and to incorporate advice into the program. An environment that realizes such a function is called an aspect-oriented environment. Currently, several aspect-oriented environments that can be used in combination with Java (registered trademark), which is an object-oriented language, are available. Here, one aspect aspect method of AspectJ is used.

In AspectJ, aspect definitions are written in the following format.
package sample;
public aspect Debug {
pointcut callHello (): execution (* sample.Hello.sayHello (..));

Object around (): callHello () {
Object t = thisJoinPoint.getTarget ();
System.out.println ("target is" + t.getClass (). GetName ());
Object result = proceed ();
System.out.println ("returning" + result);
return result;
}
}

Aspect definition consists of specifying pointcuts using pointcut clauses and implementing advice.
In the pointcut clause, for a method, execution can be executed by an execution declaration, and a call point can be specified by a call declaration. The method signature is specified in the argument of each declaration.
The signature of the method is composed of “<return value><classname>.<Methodname> (argument)”. Here, you can use * (wild card), and by specifying like say *, you can match strings that start with say like sayHello, sayGoodby.
In addition to describing the type of argument to be accepted, an arbitrary argument can also be specified by specifying ".." for the method argument.
In the pointcut clause, for the field, the read access point can be specified by the get declaration and the write access point can be specified by the set declaration. The field name is specified as an argument of each declaration.
The field name consists of “<class name>. <Field name>”. You can specify wildcards here as well as methods.

As a development environment of AspectJ, there is a tool called AJDT. By using this, it is possible to display information such as which Java class an aspect applies to. There is also a viewer that lets you see how aspects are applied to classes throughout the system.
In addition, there exists the following patent document 1 as a well-known technical document relevant to this invention.

JP 2005-258944 A

A special generation formula is used to determine (weave) an aspect in a program to be woven. This grammar is very different from existing programming languages such as Java, so it is not easy for general developers to learn and use it.
In addition, it is possible to generate an aspect at a plurality of points in a program by using a wild card or the like in this generation formula, and using this can generate an aspect efficiently. However, when this is used, it is difficult to confirm whether the aspect is correctly generated at the place where it is supposed.
In other words, the aspect generation is not so easy from the viewpoint of both the grammar and the scope of influence.

  An object of the present invention is to provide an aspect generation method and apparatus capable of easily generating an aspect to be woven into an assumed place in a program to be woven in application development using aspect-oriented programming.

In order to achieve the above object, the aspect generation apparatus of the present invention reads out a class file used in a program to be developed from the first storage means, analyzes the structure of each class in the class file, Class information used to acquire class names, method names, and signatures used in the class, and to generate class names, method names, and signature candidates defined in the generated aspect based on the acquired class names, method names, and signatures Based on the analysis result of the class structure by the analysis unit, the advice analysis unit that reads out the advice candidate performed by the aspect extracted as a common process from the second storage unit, and analyzes the data structure of the advice candidate Class names and methods for classes used in the program under development A user interface management means for displaying on the graphical user interface screen a class diagram in which a name and signature are clearly specified, and an advice candidate analyzed by the advice analysis means, and a user among the advice candidates displayed on the graphical user interface screen Class name, method name, signature candidate generated by the class information analysis means that can be selected in the class when the arbitrary icon selected by is dragged to the position of the arbitrary class in the class diagram And an aspect generation means for generating an aspect by applying the class name, method name, and signature candidate data selected by the user to the advice candidate data structure selected by the user. To
Further, the aspect generation means highlights a class name defined in the generated aspect, a method name, a class name matching the signature, a method name, and a method of a class in the class diagram having the signature. .

In the aspect generation method according to the present invention, the first means reads the class file used in the program to be developed from the first storage means, analyzes the structure of each class in the class file, The class name, method name, and signature used in the above are acquired, and based on the acquired class name, method name, and signature, the class name, method name, and signature candidate defined in the generated aspect are generated. And a second step of reading out advice candidates performed by the aspect extracted as a common process by the second means from the second storage means, and analyzing a data structure of the advice candidates, and the third means, About the class used in the development target program based on the analysis result of the class structure by the first means A third step of displaying on the graphical user interface screen a class diagram clearly indicating a class name, a method name, and a signature, and an advice candidate analyzed by the second means; Generated by the first means that can be selected in the class when an arbitrary icon selected by the user among the advice candidates displayed on the screen is dragged to the position of the arbitrary class in the class diagram The selected class name, method name, and signature candidate, and apply the class name, method name, and signature candidate data selected by the user to the advice candidate data structure selected by the user. And a fourth step of generating.
In the fourth step, the class name defined in the generated aspect, the method name, the class name matching the signature, the method name, and the method of the class in the class diagram having the signature are highlighted. To do.

The aspect generation apparatus and method of the present invention have the following effects.
(1) Assumed by the developer himself by dragging the icon of the processing (advice) to be cut out as an aspect to each candidate for the class name, method name, and method argument displayed on the graphical user interface screen Aspects can be easily generated.
(2) When an aspect is generated, it is graphically clearly shown in the class diagram that the generated aspect is woven into which method of which class, and which method and field of which class generates the generated aspect. The aspect assumed by the developer himself can be generated while confirming the affected range to be affected.

Hereinafter, an embodiment of the present invention will be described in detail with reference to the drawings.
FIG. 1 is a block diagram showing a hardware configuration example of a computer that realizes an aspect weaving apparatus according to the present invention.
A computer (101) shown in FIG. 1 includes a central processing unit (CPU) (102) and a memory (103), and is connected by a mother board (104). Further, it has a magnetic disk device (HDD) (105) and a graphic card (106) connected to the motherboard, and the graphic card (106) is connected to an external display device (107).
As an input device, a mouse (108) and a keyboard (109) are provided, and these are connected to the motherboard (104).

FIG. 2 is a functional configuration diagram functionally showing a configuration for realizing aspect weaving in the hardware configuration of FIG. 1. The aspect weaving device (201) of the present invention includes a class information analysis unit (202), class storage Unit (203), advice analysis unit (204), advice storage unit (205), aspect generation unit (206), aspect storage unit (207), and user interface management unit (208).
The class information analysis unit (202), the advice analysis unit (204), the aspect generation unit (206), and the user interface management unit (208) are specifically configured by programs stored in the memory (103). Is.
The user interface management unit (208) is connected to a mouse (108) and a keyboard (109) that constitute the display device (107) and the input device (210).

The class information analysis unit (202) is connected to the class storage unit (203) and the user interface management unit (208), and the advice analysis unit (204) is connected to the advice storage unit (205) and the user interface management unit (208). Has been. The aspect generation unit (206) is connected to the aspect storage unit (207) and the user interface management unit (208).
The class storage unit (203), advice storage unit (205), and aspect storage unit (206) are implemented on the magnetic disk device (105).

In order to extract processing (or function) common to modules or classes used in the development target program as an aspect and define it in an aspect phrase, it is necessary to grasp the processing of the module or class extracted as an aspect. . In the present invention, when generating an aspect, first, a structure of a module or class used in a program to be developed is analyzed, and a signature of a method used there is obtained. Specifically, the class diagram of the program stored in the class storage unit (203) is acquired, and the structure of each class used in the class diagram is analyzed by the class information analysis unit (202). Get the signature of the method defined in the class.
FIG. 3 is a diagram showing an example of the data format of method information of a class handled in the present invention. One method information includes ID (301), class name (302), method name (303), and argument (304). , And a return value (305). One entry corresponds to one method in the class. A method with the same name will have a different entry if its argument type is different.

FIG. 4 is a diagram showing an example of the data format of class field information. One field information is composed of an ID (401), a class name (402), and a field name (403).

As described above, it is necessary to define an advice that describes the processing to be performed by an aspect. In the present invention, advice candidates to be defined are stored in advance in the advice storage unit (205). The advice analysis unit (204) analyzes the data structure of the advice candidates stored in the advice storage unit (205). The menu is displayed on the graphical user interface screen, and the advice defined for the aspect to be cut out is selected from the menu format.
FIG. 5 is a diagram illustrating an example of a data format of advice information stored in the advice storage unit (205). One piece of advice information includes ID (501), name (502), target (503), and type. (504) and mounting (505). The name (502) is an arbitrary character string that can recognize the advice. The target (503) is a method or a field. The type (504) is one of around, before, and after. The implementation (505) becomes the program code of the advice.

FIG. 6 shows the aspect program code stored in the aspect storage unit (207). One aspect program code is composed of an aspect definition (601), a point cut definition (602), and an advice definition (603). ing.
The aspect definition (601) describes the aspect declaration by the aspect phrase and the name of the aspect.
The pointcut definition (602) describes a pointcut phrase, a pointcut name, and a pointcut designation according to the AspectJ grammar.
The advice definition (603) describes a return value of advice, an advice type, a corresponding pointcut name, and an implementation code.

FIG. 7 is a diagram showing an example of a graphical user interface screen of the aspect generation apparatus according to the present embodiment, which is roughly composed of a display area of a class diagram (701) and an advice tool box (707).
The class diagram (701) is a diagram showing the relationship between the structure (702) of the classes constituting the program stored in the class storage unit (203) and the respective relationships. The class name (703) and the field (704) of each class. , Method (705) is represented in the figure. If there is a class inheritance relationship, the classes are displayed by being linked by an arrow (706).
The class diagram (701) reads the class file described in the Java language from the class storage unit (203) when the user interface screen is displayed, and analyzes it by the class information analysis unit (202). It is displayed by converting the information and the field information of FIG. 4 and sending the information to the user interface management unit (208).

The advice toolbox (707) is an area for displaying a list of advices accumulated in the advice accumulation unit (205), an area for displaying advice for a method (708), and an area for displaying advice for a field (709). Consists of.
When displaying the graphical user interface screen, the advice tool box (707) reads the advice stored in the advice storage unit (205) in the form of the advice information shown in FIG. 5, and analyzes it with the advice analysis unit (204). The information is displayed by sending it to the user interface management unit (208).

FIG. 8 is a diagram showing an example of a menu (803) displayed when the advice (802) icon “Debug” is dragged on the method (801) of the class in the class diagram. Here, a class name pattern that can be generated is displayed as a selectable candidate.
Examples of selectable class name patterns include “*”, “Login *”, “* Dao”, and “LoginDao”. These selectable class name patterns are generated by dividing the class name used in the class diagram into several by the process described later with reference to FIG. When the class name used in the class diagram is "LoginDao", it is divided into the strings "Login" and "Dao", and "*" is added to the front and rear of these strings. By generating a class name candidate character string, it is possible to define, as a common aspect, class processing of a class name in which a character string “Login” exists in front of the class name, for example.

FIG. 9 is a diagram showing an example of the menu (904) displayed when the advice (802) is dragged onto one of the class name patterns (803) of the menu (803) displayed in FIG. It is. The method name patterns that can be set are displayed as selectable candidates.
The selectable method name pattern is also generated in the same manner as the class name pattern.

  FIG. 10 is a diagram showing an example of the menu (1005) displayed when the advice (802) is dragged onto one of the method name patterns (1004) of the menu displayed in FIG. Here, method argument patterns that can be set are displayed. This selectable method argument pattern is also generated in the same manner as the class name pattern.

FIG. 11 is a diagram showing the entire graphical user interface screen when the advice (802) is dragged onto one of the method argument patterns of the menu (1005) displayed in FIG. At this time, since the pattern of the class name, method name, and method argument is determined, the pattern of the method signature specified for the pointcut can be determined by combining these.
The method return value pattern is “*” when a wildcard is included in the class name, method name, and method argument, and is the return value of the specified method otherwise.
In the class diagram displayed on the graphical user interface screen, a method that matches the method signature pattern designated for the selected pointcut is highlighted (the shaded display portion in FIG. 11) and displayed.

  FIG. 12 is a diagram showing an example of a dialog for selecting a method pointcut type displayed on the graphical user interface screen after the method signature is selected, and the selectable pointcut types are displayed. One of them is selected using a radio button. There are two types of pointcuts for a method: execution of the method (execution) and call of the method (call).

Hereinafter, the operation of the aspect generation apparatus configured as described above will be described with reference to the flowcharts shown in FIGS.
FIG. 13 is a flowchart showing a user operation in the aspect generation process.
Here, the operation when an aspect is generated for a method will be described.
First, the user selects one advice icon (802) from the advice display area (708) of the advice tool box (707) of FIG. 7, and drags it onto the method of the class diagram (step 1301).
Then, as shown in FIG. 8, a pattern of class names that can be generated is displayed on the menu (803), and the advice (802) icon is dragged onto one of the patterns (step 1302).
Then, as shown in FIG. 9, since a pattern of method names that can be generated is displayed on the menu (904), the advice (802) icon is dragged onto one of them (step 1303).
Then, as shown in FIG. 10, since a pattern of method arguments that can be generated is displayed on the menu (1005), the advice (802) icon is dragged onto one of the patterns (step 1304).

Since the signature pattern of the method to which the advice (802) is applied is specified in this state, the method to which the aspect generated by the selection operation is applied in the class diagram displayed on the graphic user interface screen is shown in FIG. Is highlighted as shown by the shaded area.
If the advice (802) icon is dropped on the menu (step 1305), the dialog shown in FIG. 12 is displayed.
Therefore, when the type of point cut is selected (step 1306) and the OK button (1201) is pressed, the program code of the aspect shown in FIG. 6 corresponding to the condition is generated and stored in the aspect storage unit (207). Stored in
At this time, the name of the aspect used in the aspect definition (601) is the selected “advice name + Aspect + serial number”. The name of the pointcut used in the pointcut definition (602) is “the name of the selected advice (upper case is converted to lower case) + serial number”. Further, the value of the implementation field of the selected advice is entered in the implementation code of the advice definition (603).

Next, in step 1302, processing for displaying class name pattern candidates will be described with reference to the flowchart of FIG.
This process is a process for generating a character string as a pattern candidate by combining a part of the class name and “*”.
This process is a process executed by the class information analysis unit (202).
First, a candidate sequence for storing a pattern to be generated is initialized (step 1401).
The candidate sequence is a simple sequence of character strings. A class name is added to this candidate sequence as one of the patterns (step 1402).
Here, the pattern of the class name to be added is obtained from the method information (FIG. 3) stored in the class storage unit (203).

Next, the character string of the class name is divided. Here, as an example, uppercase characters are divided into divisions. For example, in the case of the UserDaoImpl class, it is divided into three parts “User”, “Dao”, and “Impl”. This is stored in the phrase array (step 1403). The phrase array is a simple string array. Here, the character string is divided with capital letters as a separator, but other methods such as a method for separating characters one by one or a method using a dictionary can also be used.
Next, a pattern character string is generated by combining the elements of the phrase array and “*”.
First, an integer value n which is an index of the array is initialized to 1 (step 1404). Then, n character strings are concatenated from the beginning of the phrase array (step 1405), and "*" is added to the end (step 1406) to generate a pattern character string and add it to the candidate array (step 1406). 1407).
Next, the index n is incremented (step 1408), and if n is smaller than the length of the array (step 1409), the processing from step 1405 is repeated.
By repeating this n-1 times, a pattern having a wild card behind is generated. For example, in the above example, the patterns User * and UserDao * are generated.
Next, the index n is initialized again with “1” (step 1410). Then, the character strings of the elements from n + 1 to the end of the phrase array are concatenated (step 1411), “*” is added to the head (step 1412), and a pattern character string is generated and added to the candidate array. (Step 1413).
Next, the index n is incremented (step 1414), and if n is smaller than the length of the array (step 1415), the processing from step 1411 is repeated.
By repeating this n-1 times, a pattern with a wild card in front is generated. For example, in the above example, the patterns * DaoImpl and * Impl are generated.
Finally, “*” is added to the candidate sequence. At this time, the pattern stored in the candidate sequence becomes a class pattern selection candidate. Patterns for method names and field names can be generated in the same way.

Next, in step 1304, when highlighting the method that matches the pattern when the class name, method name, and argument pattern are confirmed, the process of extracting the method that matches the generated pattern is shown in the flowchart of FIG. Will be described with reference to FIG. This process is a process executed by the class information analysis unit (202).
First, the Java class file stored in the class storage unit (203) is read, and the method of each class is stored in the candidate array in the method information format of FIG. 3 in the class information analysis unit (202) ( Step 1501).
Next, the result array for storing the results is initialized to an empty state (step 1502). This array is also an array according to the method information format of FIG.

Next, the array index n is initialized with “1” (step 1503).
Next, the nth element of the candidate sequence is extracted, and it is determined whether or not the class name field matches the class name pattern selected by the user (step 1504). If it matches, the method moves to the method name field. If not, the process for the element is interrupted. Next, it is determined whether or not the method name field matches the method name pattern selected by the user (step 1505). If it matches, move on to the method argument determination. If it does not match, the processing for the element is interrupted.
Next, it is determined whether the method argument field matches the method argument pattern selected by the user (step 1506). If it matches, add the element to the result array. If it does not match, the processing for the element is interrupted.
Next, it is determined whether the index n of the array is smaller than or equal to the length of the array (step 1508). If it is smaller or equal, 1 is added to n (step 1509), and the process proceeds to the next element. . If larger, the process is terminated.
At this time, the method data stored in the result array matches the pattern. This is sent to the user interface management unit (208).
The user interface management unit (208) highlights (highlights) the corresponding method on the class diagram based on this information.

The above processing will be described using the data example shown in FIG.
The method information (1601) is stored in the format shown in FIG. 3 for the candidate sequence of FIG.
Next, the first element of the candidate sequence is extracted, and the data in the class name field is compared with the class name pattern (1602). The class name pattern is “* Dao”, which indicates an arbitrary character string ending with the character string “Dao”. This is the case because the class name of this data is “LoginDao”.
Next, the data in the method name field is collated with the method name pattern (1603).
The method name pattern is “find *”, which indicates an arbitrary character string starting with the character string “find”. Here, the method name of this data is “findUser”, so this pattern is applicable.

Next, the argument field data and the argument pattern (1604) are collated. The argument pattern is “(..)”, indicating that it matches any argument. This pattern matches all argument formats, so this data also matches. Since this data matches all patterns, this data is stored in the result array (1605).
Similarly, since the second data matches all patterns, it is stored in the result array (1605).
The third data does not match the class name pattern “* Dao” because the class name is “LoginService” but is not a character string ending with “Dao”. Therefore, since this data is not data that matches these patterns, it is not stored in the result array (1605).
The fourth data matches the class name pattern “* Dao” because the class name is “OrderDao”. However, since the method name is “getOrder” and is not a character string starting with find, the method name pattern “find Does not match "*". Therefore, since this data is not data that matches these patterns, it is not stored in the result array (1605).

Thus, the first and second data out of the four data shown in FIG. 16 match this pattern.
Up to this point, the procedure for setting an aspect for a method has been described, but an aspect for a constructor and an aspect for a field can also be set in the same manner.
The constructor data is stored in the data format of the method information shown in FIG. At this time, the method name and the return value are the class name. The aspect for the constructor is set by selecting the advice for the method from the advice toolbox and dragging it to the field (703) in which the class name of the class diagram is displayed. At this time, a class name pattern menu and a method argument pattern menu are displayed. When this is selected, a dialog for selecting a pointcut type is displayed.

The pointcut type of the constructor includes a pointcut type similar to the setting for the method, when the object is initialized (initialization), and before the object is initialized (preinitialization). By selecting this, an aspect for the constructor is generated.
The field data is stored in the field information data format of FIG. The aspect for the field is set by selecting the advice for the field from the advice toolbox and dragging it to the field (704) where the field name of the class diagram is displayed. At this time, a class name pattern menu and a field name pattern menu are displayed, and when this is selected, a dialog listing the same format and pointcut types for the fields as the dialog of FIG. 12 is displayed.
There are two types of pointcut types for a field: read access to the field get and write access set to the field. By selecting this, an aspect for the field is generated.

It is a hardware block diagram of the computer used for implementation of this invention. It is a functional block diagram of the aspect production | generation apparatus of this invention. It is a figure showing the data format of the method information of a class. It is a figure showing the data format of the field information of a class. It is a figure showing the data format of advice data. It is a figure showing the program code of an aspect. It is a screen block diagram of an aspect setting device. It is a figure showing a class name pattern menu. It is a figure showing a method name pattern menu. It is a figure showing a method argument pattern menu. It is a figure showing the screen at the time of pattern setting. It is a figure showing the dialog which selects a pointcut classification. It is a flowchart which shows the outline | summary of a user's process. It is a flowchart of the process which produces | generates a class name pattern. It is a flowchart of the process which extracts the matching method. It is a figure showing the example of the data used by the process which extracts the matching method.

Explanation of symbols

DESCRIPTION OF SYMBOLS 201 Aspect generation apparatus 202 Class information analysis part 203 Class storage part 204 Advice analysis part 205 Advice storage part 206 Aspect generation part 207 Aspect storage part

Claims (4)

An aspect generation device that generates processing common to classes used in a program to be developed as an aspect,
The class file used in the development target program is read from the first storage means, the structure of each class in the class file is analyzed, and the class name, method name, and signature used in each class are obtained. , Based on the acquired class name, method name, and signature, class information analyzing means for generating a class name, method name, signature candidate defined in the generated aspect;
Advice analysis means for reading out advice candidates performed by the aspect cut out as common processing from the second storage means, and analyzing the data structure of the advice candidates;
A class diagram clearly indicating a class name, a method name, and a signature for a class used in the program to be developed based on the analysis result of the class structure by the class information analysis unit; and a candidate of the advice analyzed by the advice analysis unit; A user interface management means for displaying on a graphical user interface screen;
The class information that can be selected in the class when an arbitrary icon selected by the user among the advice candidates displayed on the graphical user interface screen is dragged to the position of an arbitrary class in the class diagram Displays the class name, method name, and signature candidate generated by the analysis means, and applies the class name, method name, and signature candidate data selected by the user to the advice candidate data structure selected by the user And an aspect generation unit for generating an aspect.   The aspect generation means highlights a method of a class in a class diagram having a class name, a method name, a class name matching the signature, a method name, and a signature defined in the generated aspect. 2. The aspect generation apparatus according to 1. An aspect generation method for generating processing common to classes used in a program to be developed as an aspect,
The first means reads the class file used in the program to be developed from the first storage means, analyzes the structure of each class in the class file, and uses the class name and method used in each class. A first step of generating a name, a signature, and generating a class name, a method name, and a signature candidate defined in the generated aspect based on the acquired class name, method name, and signature;
A second step of reading from the second storage means an advice candidate performed by the aspect cut out as a common process by the second means, and analyzing a data structure of the advice candidate;
A class diagram clearly indicating a class name, a method name, and a signature for a class used in the program to be developed based on the analysis result of the class structure by the first means; and the second means. A third step of displaying on the graphical user interface screen the advice candidates analyzed by
When an arbitrary icon selected by the user among the advice candidates displayed on the graphical user interface screen is dragged to the position of an arbitrary class in the class diagram by the fourth means, it is selected in the class. Possible class names, method names, and signature candidates generated by the first means are displayed, and the class name, method name, and signature candidate data selected by the user are displayed for the advice selected by the user. And a fourth step of generating an aspect by applying to a candidate data structure.   In the fourth step, the class name defined in the generated aspect, the method name, the class name matching the signature, the method name, and the method of the class in the class diagram having the signature are highlighted. Item 4. The aspect generation method according to Item 3.

Images