International Conference on Computer Systems and Technologies CompSysTech’2003

AN ASPECTJ PROGRAM

Figure 1
These concepts are illustrated in Figure 1. The calls to CheckSecurity() in the various classes have been removed and an aspect, aspect_Security(), has been added to provide the original functionality. In this aspect, the pointcut keyword indicates that a join point (in any of the Java classes) occurs whenever a method call to generateContents() is made. The before keyword is an example of an advice and, in this case, identifies the code to be executed immediately before the given join point is reached. Here, it is specified that CheckSecurity() is called.

The AspectJ toolkit offers the developer two choices: either to create .class files directly, or to create .java files that incorporate both the aspect and the traditional Java code and after that pass these .java files to the standard Java complier (javac). Figure 2 illustrates the second choice – the Java class code and the aspect code is “merged” to form standard Java code before being passed to the Java compiler.

Figure 2

EXAMPLES

- Increased modularity – the separation of cross-cutting concerns and their capture in a single class. Examples: aspect_Security, aspect_Logging, aspect_DBConnManagement

- Less code needs to be written – applications may be developed faster. Example: aspect_Logging

- Easier maintenance – code is no longer scattered throughout an application but localized. Examples: aspect_Security, aspect_Logging, aspect_DBConnManagement, aspect_QuantManagement

- Easier code reuse – since cross-cutting concerns are localized, they may be easily reused. Examples: aspect_Logging, aspect_DBConnManagement,

- Easier understanding, while maintaining optimisation – the code is no longer tangled, thereby allowing easier comprehension. Examples: aspect_QuantManagement, aspect_Security, aspect_DBConnManagement,

- More flexibility – with aspects there are more ways to code the same thing. - aspect_Security, aspect_Logging, aspect_DBConnManagement

- Reduced inheritance anomalies – the use of aspects allows a simpler class hierarchy.

The following examples, taken from our AspectJ implementation of the “Pet Store”, illustrate some of these advantages for the software developer. In the actual application, aspects have been used extensively.

 aspect aspect_Security: the first example demonstrates how an aspect can cope with an application-wide problem from just one place - code that would normally be scattered throughout the application may be captured in a single class using an aspect. This example deals with user authentication – the application makes sure that a user is logged in before he is allowed to view any application web page. This is diagrammatically illustrated in Figure 1. The actual aspect code is displayed in Figure 3.

Figure 3
 aspect aspect_Logging: The next example illustrates how the writing of many lines of code may be saved across the whole application. For debugging and optimisation purposes, it is frequently necessary to log function call. Such calls to the logging methods would virtually be in every function. Again, using an aspect, all the code is concentrated in one place, not scattered all over the application. The aspect code is given in Figure 4.

Figure 4
In this code, pointcut identifies a join point to be whenever a call to any function in the estore package is made. The around keyword is another advice which specifies that, whenever the join point is reached, control should be passed to this advice, and it then can decide what to do. In this case, the actual code of the original aspect-calling function is invoked via the proceed call.

With the aspect, logging can be easily switched off if no more debugging and optimisation is needed, and back on when something goes wrong and logging is required again.

 aspect aspect_DBConnManagement: The third example shows an aspect being used for database connection management, i.e. making sure that there are no open connections between the SQL server and the JSP server while the users are idle.

Figure 5
The connection of the Session Bean is opened whenever a call to the generateContents function is made, and closed with the exit from the function. This actually saves a lot of trouble, considering whether or not we have an open connection, whenever we need to execute an SQL statement.

As in the example above, the pointcut keyword specifies the join point, while the around keyword instructs what action is to be taken when the join point is reached.

 aspect aspect_QuantManagement: The last example illustrates an aspect which manages the quantity of goods in the store. It decreases the quantity of goods available for sale whenever a client confirms his order. This can be done in OOP by code in the procedure confirming the order, but this will make the code less readable as it will be mixed with code performing other tasks, resulting in harder development, debugging and maintenance. For example, consider what will happen when we also add quantity management code to the software that manages the supply of goods, and to the software that manages the dispatch of orders to the customers. A later change in the design would require finding the code about quantity management in all these parts of the application and updating it. AOP facilitates maintenance by keeping the code in just one place. With an aspect, if changes are needed, there would be no need to search for the places to apply them. As the changes may have to be done by people who did not initially build the system, AOP with its increased readability and better understanding of the source code, would further facilitate the work.

Figure 6

LESSONS LEARNED

In the previous section, we described our use of AOP in a medium-sized Java application. This description is the final view - naturally, some modifications occurred as we gained more and more experience with the technology. In this section, we provide a higher-level perspective, discussing some of the lessons we learned over the course of the development, and illustrating some of the challenges that others may face when using the aspect technology.

We can confirm the advantages cited for AOP – with aspects, less code does need to be written; code is more easily re-used; the code is easier to understand; etc. Balanced against this is the lead-time required to learn the new technology. But, as this time is one-off, the list of advantages to be gained from using AOP far outweighs this inconvenience.

However, AOP can be difficult to apply to an already completed project. If AOP is to be used, this should be known at the design phase. Initially, we tried to illustrate the use of aspects by modifying the original Pet Store Java source code. However, we soon found out that this is not the best practice. It is very difficult to extract all the code that belongs to a particular aspect into a single place, because one has to be very familiar with and go through all the code of the project.

One should also consider the fact that AspectJ is still a programming language in the process of development. While working on our application, we were unpleasantly surprised by some minor compatibility issues with some of the Java classes.

CONCLUSION

This paper has described a case study AOP implementation of the famous Java “Pet Store” application in AspectJ and reported the experiences. AOP proved to live up to our expectations. Though a still new technique, AOP is already making a great progress in the computer world. We think that it has a great potential and its popularity will be increasing until some day it makes the now traditional OOP obsolete.

REFERENCES

[1] AOP Issue, Communications of the ACM, Volume 44, Number 10, 2001

[2] AspectJ. Available from http://www.eclipse.org/aspectj/

[3] AspectJ Group. Tutorial - Aspect-Oriented Programming with AspectJ. AspectJ Workshop, Xerox PARC, 2002 http://www.parc.xerox.com/groups/csl/projects/aspectj/

[4] Elrad, T. M. Askit, G. Kiczales, K. Lieberherr, H. Ossher. Discussing Aspects of AAOP. CACM, Volume 44, Number 10, 2001

[5] Elrad, T, R. Filman, A. Bader. Aspect-Oriented Programming. CACM, Volume 44, Number 10, 2001

[6] Feng, L, A. Marcus, K. Schaffer. An Overview of Aspect-Oriented Programming

http://trident.mcs.kent.edu/~amarcus/aop/AOP_Presentation.ppt

[7] Sun Microsystems Java Pet Store specification

http://developer.java.sun.com/developer/releases/petstore/
ABOUT THE AUTHORS

1. Yuliyan Kiryakov, Department of Computer Science, American University in Bulgaria, Е-mail: JKK000@aubg.bg.

2. Prof. John Galletly, PhD, Department of Computer Science, American University in Bulgaria, Phone: +359 73 88 466, Е-mail: JGalletly@aubg.bg

- -

Directory: faculty
faculty -> Dsci 3870: Management Science
faculty -> Handling Indivisibilities
faculty -> Course overview
faculty -> Curriculum vitae wei chen professor
faculty -> Digital image warping
faculty -> Samples of Elements Exam Question III contains All Prior Exam Qs III except
faculty -> 【Education&Working Experience】
faculty -> References Abe, M., A. Kitoh and T. Yasunari, 2003: An evolution of the Asian summer monsoon associated with mountain uplift —Simulation with the mri atmosphere-ocean coupled gcm. J. Meteor. Soc. Japan, 81
faculty -> Ralph R. Ferraro Chief, Satellite Climate Studies Branch, noaa/nesdis
faculty -> Unit IV text: Types of Oil, Types of Prices Grammar: that/those of, with revision

Download 25.37 Kb.

Share with your friends: