Overview

+ * The class is thread-safe. Different threads may use different output streams + * by simply calling the method initStream(myStream).

+ * This class should be extended. + * It defines 3 abstract crosscuts for injecting the tracing functionality + * into any constructors and methods of any application classes.

Attribute	Description	Required
Specifying source and destination files
sourceroots	a list of base directories of the source files. +All source files (.java and .aj) in the base directories are compiled. + May also be specified as a nested element. +	Yes, in incremental mode.
outjar	Path to an output jar to generate with all output classes.	No
destdir	Specify where to place the generated class files.	No
classpath	the classpath required by the source files to compile. + May also be specified as a nested element. +	No
srcdir	the nested source base directory to compile, + specified as a nested element. +	No
aspectpath	the aspectpath to use -- like classpath, only for +read-only, binary aspect libraries (only accepts jar/zip files, no directories). +May also be specified as a nested element. +	No
bootclasspath	location of bootstrap class files.	No
classpathref	the classpath to use, given as a +reference to a PATH defined elsewhere.	No
bootclasspathref	location of bootstrap class files, given as a reference +to a PATH defined elsewhere.	No
Specifying compiler behavior
noweave	If true, produce binaries for the -injars option (only) -- +defaults to `false`.	No
incremental	build once, then recompile on demand only required files; + defaults to `false`. + By default, files are recompiled based on input passed to stdin + (see tagfile)	No
tagfile	File that controls when incremental builds are done + and when the task completes.	No
X	Set experimental option(s), using comma-separated list + of accepted options (unlisted here -- for XLint, use + the xlint entries). Options should not contain the leading X.	No
Specifying compiler side-effects and messages
verbose	whether to emit compiler status messages during the compile; +defaults to `false`.	No
version	if true, do not compile - just print AspectJ version; +defaults to `false`.	No
help	if true, just print help for the command-line compiler; +defaults to `false`.	No
Xlintenabled	same as `xlint:all`, +whether to emit language usage messages during the compile; +defaults to `false`.	No
Xlintfile	specify property file containing name:level associations +for any overrides to the default associations for language usage +messaged emitted during the compile.	No
failonerror	whether the build continues notwithstanding compile errors; + defaults to `true`.	No
messageholderclass	Specify a class to use as the message holder for the compile +process. The entry must be a fully-qualified name of a class resolveable +from the task classpath complying with the `org.aspectj.bridge.IMessageHolder` +interface and having a public no-argument constructor.	No
Eclipse compiler options
nowarn	same as `warn:none`; + defaults to `false`.	No
deprecation	same as `warn:deprecation`; + defaults to `false`.	No
warn	one or more comma-separated warning specifications: +constructorName, +packageDefaultMethod, +deprecation, +maskedCatchBlocks, +unusedLocals, +unusedArguments, +unusedImports, +syntheticAccess, or +assertIdentifier.	No
debug	same as `debug:lines,vars,source`	No
debuglevel	comma-separated list lines, vars, or source, + indicating to add debugging information for lines, + variables, or source	No
PreserveAllLocals	code gen preserve all local variables (for debug purposes); + defaults to `false`.	No
noimporterror	no errors for unresolved imports; + defaults to `false`.	No
referenceinfo	compute reference info; + defaults to `false`.	No
log	File to log compiler messages to.	No
encoding	default source encoding format	No
proceedonerror	keep compiling when error, dumping class files with problem methods; + defaults to `false`.	No
progress	show progress (requires log); + defaults to `false`.	No
time	display speed information; + defaults to `false`.	No
noexit	disable System.exit (kills Ant -- use failonerror); + defaults to `true`.	No
target	Specify target class file format (must be "1.1" or "1.2"); + defaults to 1.1 class file.	No
compliance	Set "1.3" or "1.4" source compliance level + (e.g., no import from default package in 1.4); + defaults to 1.3 compliance level.	No
source	source assertion mode ("1.3" or "1.4"); + default depends on compliance mode.	No

Documentation	Description
AspectJ Quick Reference + + (web) + +	This is a two-page quick reference for the AspectJ language. +
Programming Guide + (printable pdf or html + + - web + + ) +	This introduces AOP and the AspectJ language. + Getting Started + describes basic semantics, and shows development- and production-time applications. + The AspectJ Language + describes join points, pointcuts, advice, and introduction, all features new to AOP. + Examples walks you through the + examples included with the documentation, and there are two short + chapters on useful Idioms and a + few Pitfalls + The appendices have reference information: + the Quick Reference + summarizes AspectJ syntax, + the Language Semantics + best describes AspectJ usage, and + Implementation Limitations notes that + the current version is limited to code the compiler controls.
Development Environment Guide + + (printable html + + - web + + ) +	Find here a guide to the command-line compiler `ajc` + and API doc tool `ajdoc`, as well as + the AspectJ Development Environment (AJDE) for managing crosscutting + structure in JBuilder, Forte, Emacs, and the stand-alone `ajbrowser`. + (For using `ajc` and `ajdoc` in + Ant builds, + see the `taskdefs` distribution.) +
AspectJ API + + (web) + +	API documentation for AspectJ runtime classes. `JoinPoint` + shows the state automatically available at each join point. +
FAQ + + (web) + +	Frequently-asked questions about the AspectJ language, tools, and project. +
Porting guide + + (web) + +	How users can convert code from pre-1.0 versions + of AspectJ to 1.0. +
Changes + + (web) + +	Changes between the latest releases. +
Examples + + (local) + +	AspectJ code to demonstrate some language features and implement + JavaBean properties, the Observer pattern, a tracing library, + and a game application where aspects handle display updating. +

Distributions	Description
AspectJ +	The AspectJ distribution contains binaries for the + compiler, structure browser, and Ant taskdefs, + as well as the documentation and examples. + (Source code for AspectJ is available from the CVS + repositories for the AspectJ project.) +
AspectJ for Eclipse +	AspectJ Development Environment support for + Eclipse is available under the Common Public License 1.0 + from the eclipse.org project site + + http://eclipse.org/ajdt +
+ AspectJ for Emacs +	AspectJ Development Environment support for + Emacs is available under the GPL + from the sourceforge project site + + http://aspectj4emacs.sourceforge.net +
+ AspectJ for JBuilder +	AspectJ Development Environment support for + JBuilder is available under the Mozilla Public License 1.1 + from the sourceforge project site + + http://aspectj4jbuildr.sourceforge.net +
+ AspectJ for Netbeans +	AspectJ Development Environment support for + Netbeans is available under the Mozilla Public License 1.1 + from the sourceforge project site + + http://aspectj4netbean.sourceforge.net +

Resources	Description
+ user + email + list +	Developers use the + users@aspectj.org + mail list to discuss tips and + best practices for developing with AspectJ. +
+ announce + email + list +	+ announce@aspectj.org + has notices about releases and AspectJ team events. +
+ email us +	+ Email support@aspectj.org + to contact the AspectJ team directly. + (As a small team, we cannot reply as fast as + users + can for usage questions.) +
Bug + DB + and email +	Please send AspectJ bugs! (as a small program + that reproduces the problem) +
http://aosd.net - the AOSD web site +	This site has discussion and announcements related to + aspect-oriented software development (AOSD) in general. + Use announce@aosd.net + to get and publish notices about AOSD + workshops, conferences, and technology releases. + Use discuss@aosd.net + for general AOSD discussions. +

+ Frequently Asked Questions about AspectJ + Copyright (c) 1997-2001 Xerox Corporation, + 2002 Palo Alto Research Center, Incorporated. All rights reserved. + + + Last updated on the web November 26, 2002. + + + + For a list of recently-updated FAQ entries, see + AspectJ 1.1 is currently in development, and + some answers may change after it is released; + for more information, see the + AspectJ 1.1 README. + This is a web-only distribution of the FAQ; the 1.0 documentation bundle + contains an earlier version. + + + + Overview + + + What is AspectJ? + + + + AspectJ(tm) is a simple and practical extension to the + Java(tm) programming + language that adds to Java aspect-oriented programming (AOP) + capabilities. AOP allows developers to reap the benefits of + modularity for concerns that cut across the natural units of + modularity. In object-oriented programs like Java, the natural unit + of modularity is the class. In AspectJ, aspects modularize concerns that + affect more than one class. + + AspectJ includes a compiler (ajc), a + debugger (ajdb), a documentation generator + (ajdoc), a program structure browser + (ajbrowser), and integration + with Eclipse, Sun-ONE/Netbeans, GNU Emacs/XEmacs, JBuilder, and Ant. + + You compile your program using the AspectJ compiler (perhaps using + the supported development environments) and then run it, supplying + a small (< 100K) runtime library. + + + + + + What are the benefits of using AspectJ? + + + AspectJ can be used to improve the modularity of software + systems. + + Using ordinary Java, it can be difficult to modularize design + concerns such as + + + system-wide error-handling + contract enforcement + distribution concerns + feature variations + context-sensitive behavior + persistence + testing + + The code for these concerns tends to be spread out across the + system. Because these concerns won't stay inside of any one module + boundary, we say that they crosscut the + system's modularity. + + AspectJ adds constructs to Java that enable the modular + implementation of crosscutting concerns. This ability is + particularly valuable because crosscutting concerns tend to be both + complex and poorly localized, making them hard to deal with. + + + + + + + Can AspectJ work with any Java program? + + + AspectJ has been designed as a compatible + extension to Java. By compatible, we mean + + + + + + + upward compatible + + All legal Java programs are legal AspectJ + programs. + + + + + platform + compatible + + + All legal AspectJ programs run on standard Java + virtual machines. + + + + + tool + compatible + + + Existing tools can be extended to work with + AspectJ. + + + + + programmer compatible + + Programming in AspectJ feels natural to Java + programmers. + + + + + + The AspectJ tools run on any Java 2 Platform compatible + platform. The AspectJ compiler produces classes that run + on any Java 1.1 (or later) compatible platform. + + + + + + How is AspectJ licensed? + + + The AspectJ tools are open-source software available under the + Mozilla Public License 1.1. + The documentation is available under a separate + + license + that precludes for-profit or commercial + redistribution. Generally, we permit some usage for + internal presentations; please contact us at + support@aspectj.org + for permission. + + Most users only want to use AspectJ to build programs they distribute. + There are no restrictions here. When you distribute your program, be sure to + include all the runtime classes from the aspectjrt.jar for that version of AspectJ. + When distributing only the runtime classes, you need not provide any notice that + the program was compiled with AspectJ or includes binaries from the AspectJ project, + except as necessary to preserve the warranty disclaimers in our license. + Although the license does not require it, please email + support@aspectj.org + if you are shipping applications built with AspectJ; knowing that is + critical for ongoing support from our sponsors. + + + + + + + + What is the AspectJ Project? + + + AspectJ is based on over ten years of research at + + Xerox Palo Alto Research Center + + as funded by Xerox, a U.S. Government grant (NISTATP), and a + DARPA contract. + + It has evolved through open-source releases to a strong + user community. + The AspectJ team works closely with the community + to ensure AspectJ continues to evolve as an effective + aspect-oriented programming language and tool set. + + The latest release is 1.0.6 + which can be downloaded from the AspectJ + download page. + Further development is focused on supporting applications, + improving performance of the 1.0 compiler, + enhancing integration with IDEs, + and building the next generations of the language. + + + + + + Quick Start + + + + What Java versions does AspectJ require and support? + + + + + The AspectJ compiler produces programs for any released version of the + Java platform (jdk1.1 and later). When running, your program classes must + be able to reach classes in the + small (< 100K) runtime library (aspectjrt.jar) from the distribution. + The tools themselves require Java 2 (jdk 1.2) or later to run, + but the compiler can be set up to target any 1.1-compliant + version of the Java platform. + + + + + + How do I download and install AspectJ? + + + Go to AspectJ's + download web + page + and choose which components you want download. + The jar files are installed by executing + + + java -jar jar file name + + Do not try to extract the + jar file contents and then attempt to execute + java org.aspectj.Main. (A + NoClassDefFoundError exception will be + thrown.) The AspectJ distribution is not designed to be installed + this way. Use the java -jar form shown above. + + The compressed tar files (suffix: + .tgz) are extracted by decompressing them with + tar or with WinZip. + + To uninstall, remove the files the installer wrote in your + file system. In most cases, you can delete the top-level install + directory (and all contained files), after you remove any + new or updated files you want to keep. On Windows, no + registry settings were added or changed, so nothing needs to be + undone. You may install over prior versions, but if the files are + locked the installer will warn you but still complete; in this case, + remove the locked files and reinstall. + + + + + + How should I start using AspectJ? + + + Many users adopt AspectJ incrementally, first using it + to understand and validate their systems (relying on it only in + development) and then using it to implement crosscutting concerns + in production systems. AspectJ has been designed to make each + step discrete and beneficial. + + + In order of increasing reliance, you may use AspectJ: + + + + + In the development + process + Use AspectJ to trace or log + interesting information. You can do this by adding + simple AspectJ code that performs logging or tracing. + This kind of addition may be removed ("unplugged") for + the final build since it does not implement a design + requirement; the functionality of the system is unaffected by + the aspect. + + + + + As an ancillary part of your + system + Use AspectJ to more completely and + accurately test the system. + Add sophisticated code that can check contracts, + provide debugging support, or implement test strategies. + Like pure development aspects, this code may also be + unplugged from production builds. However, the same code + can often be helpful in diagnosing failures in deployed + production systems, so you may design the functionality + to be deployed but disabled, and enable it when debugging. + + + + + As an essential part of your + system + Use AspectJ to modularize + crosscutting concerns in your system by design. + This uses AspectJ to implement logic integral to a system + and is delivered in production builds. + + + + This adoption sequence works well in practice and has been + followed by many projects. + + + + + + How does AspectJ integrate with existing Java development + tools? + + + + AspectJ products are designed to make it easy to integrate + AspectJ into an existing development process. + Each release includes + Ant taskdefs for building programs, + the AspectJ Development Environment (AJDE) for writing + aspects inside popular IDE's, and + command-line tools for compiling, documenting, and debugging. + + + AspectJ provides replacements for standard Java tools: + + + ajc, the AspectJ compiler, + runs on any Java 2 compatible platform, and produces classes + that run on any Java 1.1 (or later) compatible platform. + + + + ajdoc works like + Sun's javadoc API documentation generator + to produce HTML describing the semantics of Java and + AspectJ source files, including entries and cross-references + for the crosscutting structure. + + + + ajdb is an aspect-aware debugger + akin to Java's jdb. + + + + + The AspectJ Development Environment (AJDE) + enables programmers to view and navigate the crosscutting structures + in their programs, integrated with existing support in + popular Java IDE's for viewing and navigating object-oriented + structures. For many programmers this provides a deeper understanding + of how aspects work to modularize their concerns and permits them + to incrementally extend their development practices without + having to abandon their existing tools. + + + AJDE integrates with the following tools: + + + + Borland's JBuilder (versions 4 and 5) + + + Sun Microsystems' Forte for Java (versions 2 and 3), + and Netbeans 3.2 + + + + Eclipse (version 2.0) + + + GNU Emacs (version 20.3) and XEmacs (version 21.1 on Unix + and 21.4 on Windows) + + + + + The common functionality of AJDE is also available in + the stand-alone source code browser ajbrowser, + included in the tools distribution. + + AspectJ also supports building with Ant by providing + taskdef interfaces to the ajc and ajdoc tools. + + + + + + Typical AspectJ programs + + + Are aspects always optional or non-functional parts of + a program? + + + + No. Although AspectJ can be used in a way that allows AspectJ + code to be removed for the final build, aspect-oriented code is not + always optional or non-functional. Consider + what AOP really does: it makes the modules in a program correspond + to modules in the design. In any given design, some modules are + optional, and some are not. + + The examples directory included in the AspectJ distribution + contains some examples of the use aspects that are not optional. + Without aspects, + + + + + + + bean + + Point objects would not be JavaBeans. + + + + introduction + + Point objects would not be cloneable, comparable or + serializable. + + + + + spacewar + + Nothing would be displayed. + + + + telecom + + No calls would be billed. + + + + + + + + + + What is the difference between development and production aspects? + + + + + Production aspects are delivered with the finished product, + while development aspects are used during the development process. + Often production aspects are also used during development. + + + + + + + What are some common development aspects? + + + + Aspects for logging, tracing, debugging, profiling + or performance monitoring, or testing. + + + + + + + What are some common production aspects? + + + + + Aspects for performance monitoring and diagnostic systems, + display updating or notifications generally, security, + context passing, and error handling. + + + + + + Basic AOP and AspectJ Concepts + + + What are scattering, tangling, and crosscutting? + + + + "Scattering" is when similar code is distributed throughout many + program modules. This differs from a component being used by + many other components since + it involves the risk of misuse at each point and of inconsistencies + across all points. Changes to the implementation may require + finding and editing all affected code. + + "Tangling" is when two or more concerns are implemented in + the same body of code or component, making it more difficult to understand. + Changes to one implementation may cause unintended changes + to other tangled concerns. + + "Crosscutting" is how to characterize a concern than spans + multiple units of OO modularity - classes and objects. Crosscutting + concerns resist modularization using normal OO constructs, but + aspect-oriented programs can modularize crosscutting concerns. + + + + + + What are join points? + + + Join points are well-defined points in the execution of a + program. Not every execution point is a join point: only those + points that can be used in a disciplined and principled manner are. + So, in AspectJ, the execution of a method call is a join point, but + "the execution of the expression at line 37 in file Foo.java" is + not. + + The rationale for restricting join points is similar to the + rationale for restricting access to memory (pointers) or + restricting control flow expressions (goto) in + Java: programs are easier to understand, maintain and extend + without the full power of the feature. + + AspectJ join points include reading or writing a field; calling + or executing an exception handler, method or constructor. + + + + + + + What is a pointcut? + + + + A pointcut picks out + + join points + . These join points are described by the pointcut + declaration. Pointcuts can be defined in classes or in aspects, + and can be named or be anonymous. + + + + + + What is advice? + + + Advice is code that executes at each + join point picked out by a + pointcut. There are three + kinds of advice: before advice, around advice and after advice. As + their names suggest, before advice runs before the join point + executes; around advice executes before and after the join point; + and after advice executes after the join point. The power of + advice comes from the advice being able to access values in the + execution context of a pointcut. + + + + + + What are inter-type declarations? + + + AspectJ enables you to declare members and supertypes of another class + in an aspect, subject to Java's type-safety and access rules. These are + visible to other classes only if you declare them as accessible. + You can also declare compile-time errors and warnings based on pointcuts. + + + + + + What is an aspect? + + + Aspects are a new class-like language element that has been + added to Java by AspectJ. Aspects are how developers encapsulate + concerns that cut across classes, the natural unit of modularity in + Java. + + Aspects are similar to classes because... + + aspects have type + + + aspects can extend classes and other aspects + + + + + aspects can be abstract or concrete + + + + + non-abstract aspects can be instantiated + + + + aspects can have static and non-static state and + behavior + + + + aspects can have fields, methods, and types + as members + + + + the members of non-privileged aspects follow the + same accessibility rules as those of classes + + + + + Aspects are different than classes because... + + + aspects can additionally include as members pointcuts, + advice, and inter-type declarations; + + + + aspects can be qualified by specifying the + context in which the non-static state is available + + + + aspects can't be used interchangeably with + classes + + + + aspects don't have constructors or finalizers, + and they cannot be created with the new operator; + they are automatically available as needed. + + + + privileged aspects can access private members of + other types + + + + + + + + + Why AOP? + + + Are crosscutting concerns induced by flaws in parts of the + system design, programming language, operating system, etc. Or is + there something more fundamental going on? + + + + AOP's fundamental assumption is that in any sufficiently + complex system, there will inherently be some crosscutting + concerns. + + So, while there are some cases where you could re-factor a + system to make a concern no longer be crosscutting, the AOP idea + is that there are many cases where that is not possible, or where + doing so would damage the code in other ways. + + + + + + Does it really make sense to define aspects in terms of + crosscutting? + + + + Yes. + The short summary is that it is right to define AOP in terms of + crosscutting, because well-written AOP programs have clear + crosscutting structure. It would be a mistake to define AOP in + terms of "cleaning up tangling and scattering", because that isn't + particular to AOP, and past programming language innovations also + do that, as will future developments. + + Slides for a long talk on this topic are at + + http://www.cs.ubc.ca/~gregor/vinst-2-17-01.zip + . + + + + + + Is AOP restricted to domain-specific + applications? + + + + No. Some implementations of AOP are domain-specific, but + AspectJ was specifically designed to be general-purpose. + + + + + + Why do I need AOP if I can use interceptors + (or JVMPI or ref + lection)? + + + + There are many mechanisms people use now to implement + some crosscutting concerns. But they don't have a way to express + the actual structure of the program so you (and your tools) + can reason about it. Using a language enables you to express the + crosscutting in first-class constructs. You can not only avoid the + maintenance problems and structural requirements of some other + mechanisms, but also combine forms of crosscutting so that all + the mechanisms for a particular concern are one piece of code. + + + + + + Related Technology + + + + How does AspectJ compare to other new forms of programming? + + + + There are many recent proposals for programming languages that + provide control over crosscutting concerns. Aspect-oriented + programming is an overall framework into which many of these + approaches fit. AspectJ is one particular instance of AOP, + distinguished by the fact that it was designed from the ground up + to be compatible with Java. + + See the + Related + Sites + page of the AspectJ web site for more + information. + + + + + + How do you compare the features of AspectJ with + reflective systems? + + + + Reflective and aspect-oriented languages have an important + similarity: both provide programming support for dealing with + crosscutting concerns. In this sense reflective systems proved + that independent programming of crosscutting concerns is + possible. + + But the control that reflection provides tends to be low-level + and extremely powerful. In contrast, AspectJ provides more + carefully controlled power, drawing on the rules learned from + object-oriented development to encourage a clean and understandable + program structure. + + + + + + How do AspectJ features compare with those of mixin-based + inheritance? + + + + Some features of AspectJ, such as introduction, are related to + mixin-based inheritance. But, in order to + support crosscutting, a core goal for AspectJ, AspectJ goes beyond + mixin-based inheritance. + + Firstly, an aspect imposes behavior on a class, rather than a + class requesting behavior from an aspect. An aspect can modify a + class without needing to edit that class. This property is + sometimes called reverse inheritance. + + Secondly, a single aspect can affect multiple classes in + different ways. A single paint aspect can add different paint + methods to all the classes that know how to paint, unlike mixin + classes. + + +So mixin-based inheritance doesn't have the reverse inheritance +property, and mixins affect every class that mixes them in the same. +If I want to do something like SubjectObserverProtocol, I need two +mixins, SubjectPartofSubjectObserverProtocol and ObserverPartof... +In AspectJ, both halves of the protocol can be captured in a single +aspect. + + + + + + What is the relationship between AOP and + XP (extreme programming AKA agile methods)? + + + + From a question on the user list: + +> Anyone know the connections between AOP and Extreme Programming? +> I am really confused. It seems AOP is a programming paradigm, which +> is the next level of abstraction of OOP. Extreme Programming, however, +> this is a lightweight software development process. One of the common +> motivations of AOP and XP is designed to adopt to the requirement +> changes, so that it can save the cost of software development. + + + + This is Raymond Lee's answer: + + + You're not really that confused. AOP and XP are orthogonal concepts, + although AOP can be used to help accomplish XP goals. + One of the goals of XP is to respond to changing requirements. + Another is to reduce the overall cost of development. These are + not necessarily the same thing. + + + One of the principles of XP that contribute to meeting those goals + is to maintain clean, simple designs. One of the criteria for clean, + simple designs is to factor out duplication from the code. Benefits + of removing duplication include the code being easier to understand, + better modularity of the design, lower costs of code changes, less + chance of conflicting changes when practicing collective code + ownership, etc. + + + Different types of duplication lend themselves to being addressed by + different design paradigms and language features. Duplicate snippets + of code can be factored out into methods. Duplicate methods can be + factored out to common classes, or pushed up to base classes. + Duplicate patterns of methods and their use can be factored out to + mechanisms of classes and methods (i.e. instantiations of design + patterns). + + + AOP addresses a type of duplication that is very difficult to handle + in the other common paradigms, namely cross-cutting concerns. By + factoring out duplicate cross-cutting code into aspects, the target + code becomes simpler and cleaner, and the cross-cutting code becomes + more centralized and modular. + + + So, AOP as a paradigm, and the associated tools, gives an XPer, or + anyone wanting to remove duplication from the code base, a powerful + way to remove a form of duplication not easily addressed until now. + + + + + + Will you support C#? + + + Not at this time. Although the resemblances between C# and Java + means it would probably be a fairly straightforward matter to take + the AspectJ language design and produce AspectC#, our current focus + is only on supporting effective uses of AspectJ. + + + + + + Deciding to adopt AspectJ + + + + Is it safe to use AspectJ in my product plans? + + + + You may use AspectJ in your product or project with little + risk. Several factors play a role in reducing the risk of adopting + this new technology: + + + AspectJ is an addition to + Java, and can be incrementally introduced into a project + in a way that limits risk. + See for + some suggestions on how to do this. + + + + The AspectJ compiler accepts standard Java as + input and produces standard Java bytecode as output. An + optional mode produces standard Java source code which may + then be compiled with any compliant Java compiler, e.g. Sun's + javac compiler + or IBM's jikes compiler. + + + + AspectJ is available under the + Mozilla Public License, + a non-proprietary, open source license. This ensures that + AspectJ will continue to evolve and be available, regardless + of the fate of any particular organization involved with + AspectJ. + + + + Removing AspectJ from your program is not + difficult, although you will lose the flexibility and + economy that AspectJ provided. + + + + + + + + + What is the effect of using AspectJ on the source code + size of programs? + + + + Using aspects reduces, as a side effect, the number of source + lines in a program. However, the major benefit of using aspects + comes from improving the modularity of a + program, not because the program is smaller. Aspects gather into a + module concerns that would otherwise be scattered across or + duplicated in multiple classes. + + + + + + + Does AspectJ add any performance overhead? + + + + The issue of performance overhead is an important one. It is + also quite subtle, since knowing what to measure is at least as + important as knowing how to measure it, and neither is always + apparent. + + There is currently no benchmark suite for AOP languages in + general nor for AspectJ in particular. It is probably too early to + develop such a suite because AspectJ needs more maturation of the + language and the coding styles first. Coding styles really drive + the development of the benchmark suites since they suggest what is + important to measure. + + In the absence of a benchmark suite, AspectJ probably has an + acceptable performance for everything except non-static advice. + Introductions and static advice should have extremely small + performance overheads compared to the same functionality + implemented by hand. + + The ajc compiler will use static typing information + to only insert those checks that are absolutely necessary. Unless you use + 'thisJoinPoint' or 'if', then the only dynamic checks that will be + inserted by ajc will be 'instanceof' checks which are generally quite fast. + These checks will only be inserted when they can not be inferred from + the static type information. + + If you'd like to measure the performance be sure to write code + fragments in AspectJ and compare them to the performance of the + corresponding code written without AspectJ. For example, don't + compare a method with before/after advice that grabs a lock to just + the method. That would be comparing apples and oranges. Also be + sure to watch out for JIT effects that come from empty method + bodies and the like. Our experience is that they can be quite + misleading in understanding what you've measured. + + + + + + + I've heard that AspectJ leads to modularity violations. Does it? + + + + + Well I haven't yet seen a language in which you can't write bad code! + + + But seriously, most AspectJ users find that just like when they learned + OO, it takes a while to really get the hang of it. They tend to start + in the usual way, by copying canonical examples and experimenting with + variations on them. + + + But users also find that rather than being dangerous, AspectJ helps them + write code that is more clear and has better encapsulation -- once they + understand the kind of modularity AspectJ supports. There are several + good papers that talk about this (see below), but here's a basic point + to keep in mind: when properly used, AspectJ makes it possible program + in a modular way, something that would otherwise be spread throughout + the code. Consider the following code, adapted from the AspectJ tutorial: + + +aspect PublicErrorLogging { + Log log = new Log(); + + pointcut publicInterface(Object o): + call(public * com.xerox.*.*(..)) && target(o); + + after(Object o) throwing (Error e): publicInterface(o) { + log.write(o, e); + } +} + + + The effect of this code is to ensure that whenever any public method of + an interface or class in the com.xerox package + throws an error, that error is logged before being thrown to its caller. + + + Of course in the alternative implementation a large number of methods + have a try/catch around their body. + + + The AspectJ implementation of this crosscutting concern is clearly + modular, whereas the other implementation is not. As a result, if you + want to change it, its easier in the AspectJ implementation. For + example, if you also want to pass the name of the method, or its + arguments to log.write, you only have to edit + one place in the AspectJ code. + + + This is just a short example, but I hope it shows how what happens + with AOP and AspectJ is that the usual benefits of modularity are + achieved for crosscutting concerns, and that leads to better code, + not more dangerous code. + + + One paper someone else just reminded me of that talks some more + about this is: + + http://www.cs.ubc.ca/~kdvolder/Workshops/OOPSLA2001/submissions/12-nordberg.pdf + + + + + + + + Why does AspectJ permit aspects to access and add members of another type? + Isn't that violating OO encapsulation? + + + + In the spirit of Smalltalk, we have decided to give more power + to the language in order to let the user community experiment and + discover what is right. To date this has proven to be a successful + strategy because it has permitted the construction of many useful + aspects that crosscut the internal state of an object, and as such + need access the its private members. However, we are not + discounting that some sort of restrictions are useful, rather, we + are seeking input from the community in order to decide on what + these restrictions should be. + + + In that light, our position on encapsulation is : + + + we respect Java's visibility rules + we also provide open-classes, a mature OO technology + we provide "privileged" access if you really need it. + + + Introducing parents or members to classes is a well-studied OO technique + known as open classes. + + + Open classes have been used in many languages prior to AspectJ, + including CLOS, Python, Smalltalk, Objective-C, and others. + Building from Java, introduction in AspectJ provides better + name hygiene and access control than prior languages. + Introduced code obeys all of Java's normal accessibility rules + for its lexical location in the aspect that it is introduced from. + Such code can not even see, much less access, private members of + the class it is introduced into. Further, introductions can be + declared private to the aspect, so they are not visible to + other clients of the class. + + + Privileged aspects do permit access to private members of another + class. They are a response to the very few cases where developers + genuinely need such access (typically for testing purposes where it + access is necessary), but it would be more risky to open access by + putting the aspect in the same package, adding test code, or changing + access in the target class. We recommend using privileged aspects + only as necessary, and believe that marking them "privileged" makes + any potential misuse apparent. + + + + + + Can I use AspectJ with J2EE? + + + + Consider the component types in J2EE: + + + + + Servlet: AspectJ works well within servlets + + + + + JSP: It is possible to use AspectJ to affect code in JSPs by precompiling + them into Java sources and compiling these with ajc. This can be used, e.g., to + customize displays by turning on and off custom JSP taglibs. The mapping from a + given jsp source to java package and class name is not standardized, which means + doing this imposes dependencies on specific container versions. + + + + + EJB: AspectJ supports a wide variety of aspects for EJBs. It can be used for + logging, tracing, debugging, error handling by layers, correlated method-level + interception (e.g., chargebacks), metering, fine-grained transactions, etc. + Indeed, it can be used to enforce adherence to coding restrictions within an + EJB (e.g., not using java.io, creating a class loader, or listening on + sockets) using declare error. + + + + + The basic limitations are that there is no built-in support for writing J2EE + analogs for AspectJ extensions to Java, like distributed aspects, distributed + cflow, or managing state between invocations. These don't prevent one from using + AspectJ to do useful intra-container implementation, nor need they prevent one + from building distributed support, state management, and inter-component + implementations that leverage AspectJ. It just takes some work. In more detail: + + + All AspectJ implementations may define "code the implementation controls". + The AspectJ 1.0 implementation defines this as the files passed to the compiler + (AspectJ 1.1 will also support bytecode weaving). + + + Some advice on EJB operations will generate methods that confuse ejb compilers. + To avoid this problem, you can use the -XaddSafePrefix flag when compiling with ajc. + + + EJB components may be invoked remotely, and containers may passivate and + pool EJB's. Servlets have similar limitations, and in both cases the + lifespan of the defining class loader is implementation-dependent + (though it must span the operation of a particular request). + + + Being limited by lifecycle and namespace, the AspectJ 1.0 implementation + supports aspects that operate through non-remote invocations during the lifetime + of the namespace for a particular + deployment unit compiled in its entirety by the ajc compiler. + This means AspectJ supports common aspects only within a single local runtime + namespace (usually implemented as a class loader hierarchy). + + + Further, AspectJ recognizes language-level join points (object initialization, + method calls, etc.), not their EJB analogs (ejb find or create methods...). + These lead to the following consequences: + + + + + Issingleton aspects (the default) are limited to the lifetime of + the defining class loader, which in some implementations may not span + multiple invocations of the same application or EJB component. + + + + + EJB lifecycles are different from object lifecycles, so perthis + and pertarget aspects will make little sense. They do not work + in the current implementation, which uses synchronized methods + to ensure a correct association in threaded environments + (EJB's may not have synchronized methods). + + + + + Percflow or percflowbelow aspects are restricted to a chain of + non-remote invocations. While EJB 2.0 permits declaring an interface + local, this information is not available to the AspectJ compiler today. + For same reasons as stated above fore perthis, these will not work even + in the EJB container. + + + + + Evaluation of cflow or cflowbelow pointcuts will be valid only + with respect to a chain of non-remote invocations. + + + + + In addition, any AspectJ code should respect EJB operations: + + + + + The EJB container accesses EJB component fields directly, i.e., + in code outside the control of the compiler. There is no join point for + these accesses, and hence no way to write a pointcut to advise that access. + + + + + The EJB container may pool EJB components, so any initialization + join points may run once per component constructed, not once per + component initialized for purposes of a client call. + + + + + The EJB container is permitted to change class loaders, even + between invocations of a particular EJB component (by passivating and + activating with a new class loader). In this case, instances of singleton + aspects will not operate over multiple invocations of the component, or that + static initialization join point recur for a given class as it is re-loaded. + This behavior depends on the container implementation. + + + + + + + + Can I use AspectJ with Generic Java? + + + At this time, unfortunately not. The two compilers are just not + at all compatible. In an ideal world, there would be a wonderful + Open Source extensible compiler framework for Java that both GJ and + AspectJ would be built on top of, and they would seamlessly + interoperate along with all other extensions to Java that you might + be interested in, but that's not the case (yet?). + + However, on 09 October 2000, the Java Community Process + approved a proposal to add generic types to Java that is largely + based on GJ (JSR 14). A draft specification was submitted for + public review, which closed on 01 August 2001, and a + + prototype implementation + has been released. + + We are committed to moving very rapidly to add support for + generic types in AspectJ when generic types become part of the Java + language specification. Everyone on the AspectJ team is looking + forward to this, because we too would really like to be able to + write code that includes both aspects and generic types. + + + + + + Are you working to put AOP into Java? + It seems that every AOP toolset currently uses proprietary mechanisms + to describe point-cuts, etc. + + + + + We are working on standardization, but it's + a question of timing/ripeness (imagine going from thousands of users + to millions). (See .) We believe + AspectJ addresses this question in the best way possible now: + + + + It's open-source. Rather than being proprietary or controlled by a + vendor, it's available for anybody to use and build upon, forever. + + + + + AspectJ is not a set of mechanisms, it's a language. It is currently + implemented using certain techniques, but there's nothing that prevents + it from being implemented with other techniques. That means users can + adopt the language with confidence that implementations will get better. + + + + + There is no engineering need to change Java. The AspectJ language uses + the join point model already in Java, so there is no need to extend the + programming model. Our implementation produces valid Java bytecode, which + runs in any compliant J2SE VM and supports standard debuggers for those VM's + that support JSR-45 (debugging support for multi-language/multi-file sources). + This is a huge benefit to Sun since Sun must be extremely cautious + about extensions to the language or VM; before adopting AOP, Sun should + demand the kind of actual-proof that AspectJ implementations offer. + + + + + On the issue of "proprietary mechanisms to describe pointcuts, etc.": Any AOP + has to have some language to describe pointcuts and the like ("pointcuts" + of course being the AspectJ term). Users would like to have one language + (to avoid having to learn or transform between many languages) and the + choice of multiple implementations (tailored for a configuration, subject + to competitive pressure, etc.). That's what AspectJ offers. + + + + + That said, we believe the AspectJ extensions to Java could form the basis + for bringing AOP to Java; when that happens, there will be engineering + opportunities to make the implementation and tool support better. + + + + + + + + + What kind of support is available? + + + + The AspectJ users mailing list provides an + informal network of AspectJ experts. To subscribe, + visit the Mailing Lists + page of the AspectJ web site. + + If you have a problem that is not a bug, you may email + the AspectJ team at + support@aspectj.org. + You may view and submit bug reports and feature requests at + http://aspectj.org/bugs. + + Members of the AspectJ team are available to work with users in + more depth on both program design and implementation issues. + The team also presents educational courses and speakers for + interested groups and offers commercial support + and consulting for businesses. + Please contact the + AspectJ team. + with your request. + + + + + + Using the AspectJ compiler + + + + What files do I need to include when compiling AspectJ programs? + + + + You need to specify to the compiler the source files that + contain your aspects and the source files that contain the + types affected by your aspects. + See . + The AspectJ compiler will not search the source path for types + that may be affected (unlike Javac and Jikes), and it only uses + aspects in source form. + + In some cases you should compile your entire system all at once. + If this is too slow, then you can try to make reasonable divisions + between sets of source files whose aspects do not interact to + achieve a shorter compile cycle (particularly for development + aspects). However, if you get any problems + or if you wish to run tests or do a release, you should recompile + the entire system. + + + + + + I have to list many files in the command line to + compile with ajc. Is there any other way to + provide the file names to ajc? + + + + + Yes, use the argfile option to ajc. List source + files in a line-delimited text file and direct ajc to that + file using -argfile or @: + + ajc @sources.lst +ajc -argfile sources.lst + + + For more information, see the ajc tool + section of the + + Development Environment Guide + . + + + + + + What Java virtual machine (JVM) do I use to run the + AspectJ compiler? + + + + Use the latest, greatest, fastest JVM you can get your hands on + for your platform. The compiler's performance is dependent on the + performance of the JVM it is running on, so the faster a JVM you + can find to run it on, the shorter your compile times will be. At a + minimum you need to use a Java 2 or later JVM to run the compiler. + We realize that this constraint can be a problem for users who + don't currently have a Java 2 JVM available. We're sorry for the + inconvenience, but we had to make the hard decision that the + advantages of being able to rely on Java 2 were worth the cost of + losing a number of developers who are working on platforms without + Java 2 support. Here is a list of starting places where you might + find support for your system. + + + + Java 2 + Platform, Standard Edition + + + + + + + developerWorks : J + ava technology : Tools and products - Developer kits + + + + + + + developerWorks : Open Source - Jikes Project + + + + + + Java + Platform Ports + + + + + + The requirement of Java 2 support is only for + running the AspectJ compiler. The AspectJ + compiler can be used to build programs that will run on Java 1.1 + (or probably even on Java 1.0) systems. This means that it can + build programs that will run on Macintosh, FreeBSD, and applets + that will run in Internet Explorer and Netscape Navigator that are + still not yet Java 2 compliant. + + + + + + How can I use ajc to compile + programs for a JVM that is different from the one used to run it? + + + + + ajc can be used to develop programs that are + targeted at the Java 1.1 platform, even though the + ajc compiler won't run on that platform. Here's + an example of using ajc in this sort of + cross-compilation mode (assuming a Windows platform with all the + default installation directories): + + +ajc -target 1.1 -bootclasspath c:\jdk1.1.7\lib\classes.zip \ + -classpath c:\aspectj1.0\lib\aspectjrt.jar -extdirs "" \ + -argfile jdk11system.lst + + This same technique can be used if you want to run + ajc on a JDK 1.3 JVM (highly recommended) but + need to generate code for JDK 1.2. That would look something + like: + + +ajc -bootclasspath c:\jdk1.2\jre\lib\rt.jar \ + -classpath c:\aspectj1.0\lib\aspectjrt.jar \ + -extdirs c:\jdk1.2\jre\lib\ext + -argfile jdk12system.lst + + + + + + Does the ajc compiler support + the assert keyword in Java 1.4? + + + + Yes. As with Javac, + use the -source 1.4 option as described + in the ajc tool section + of the + + Development Environment Guide + . + + + + + + Are there any issues using AspectJ with the Microsoft + JVM? + + + + Since AspectJ requires Java 2 or later, it will not run on the + Microsoft JVM, which does not support Java 2. + + + + + + Does ajc rely + on javac for generating Java bytecode + (.class) files? + + + + No. Some previous versions of AspectJ had this requirement, + and javac can still be used as + ajc back end by using the + -usejavac flag. You can also run ajc + in preprocessor mode to generate Java source + (.java) files to be compiled using + javac or another java compiler. + + + + + + + I noticed the AspectJ compiler doesn't use a parser generator. Why is that? + + + + + The PARSER for ajc is written by hand. This choice was made with full + awareness of the generator tools out there. (Jim had for example used + the excellent javacc tool for building the parser for JPython (now Jython)). + One of the reasons that AspectJ uses a hand-written parser is that using + javacc taught Jim about the LL-k design for parsers (pioneered by antlr). + As opposed to the state-machine parsers produced by yacc, these parsers are + very readable and writable by humans. + + + Antlr and javacc did not really suit the project: + + + + + Antlr's support for unicode in the lexer is still immature and this makes + using it with Java challenging. This was an even bigger issue 3 years ago + when we started on the Java implementation of ajc. + + + + + While javacc is freely available, it is not Open Source. Depending on a + closed-source tool to build an Open Source compiler would reduce some + of the transparency and control of open-source. + + + + + There were also several things that were easier to implement with + a hand-written parser than with any of the exiting tools. + + + + + Semi-keywords -- it's important to us that + "every legal Java program is also a legal AspectJ program." + This wouldn't be true if we made 'before' and 'call' full keywords in + AspectJ. It is easier to support these sorts of semi-keywords with a + hand-written parser. (Note: ajc-1.0.x handles 'aspect' and 'pointcut' + slightly specially which can break a few unusual pure Java programs. + This is a compiler limitation that will be fixed in a future release.) + + + + + Deprecated syntax warnings -- the syntax of AspectJ + changed many times from version 0.2 to the 1.0 release. It was easier + to provide helpful warning messages for these changes with our + hand-written parser. + + + + + Grammar modularity -- We like being able to have + AspectJParser extend JavaParser. + + + + + Part of the grammar for AspectJ is extremely hard for existing tools to + capture. This is the type pattern syntax, i.e. "com.xerox..*.*(..)". + The sort of case that gives standard parser generators fits is something + like "*1.f(..)" which no one would ever write, but which must be + supported for a consistent language. + + + + + + + + Integrating AspectJ into your development environment + + + How do I know which aspects affect a class when looking + at that class's source code? + + + + When you are working with the IDE support, you can get an + understanding of which aspects affect any class. + This enables AspectJ programmers to get the benefits of + modularizing crosscutting concerns while still having immediate + access to what aspects affect a class. + + For example, the + + Development Environment Guide + section + on ajbrowser shows that you can list or navigate + between method and advice affecting that method and between a type + and declarations in an aspect on that type. (The IDE support may + have more features than ajbrowser, depending + on the IDE.) + + + When you are looking at documentation, + ajdoc will provide links from aspects and + advice to the affected code, but it provides less information + than the IDE support because it only parses declarations. + + + When you are running your program, + you can trace advice as it executes. This + enables you to identify advice on join points picked out + dynamically, which cannot be reflected precisely by IDE support. + + See for more + information on which Java development environments are + supported. + + + + + + What kind of IDE support is available for developing + AspectJ programs? + + + + See + + + + + I want the aspects for development builds but + remove them for production builds. How can I set up the build + system so they are unpluggable? And so I use javac + in my production build? + + + + + If you are using development-time-only aspects - aspects that only + exist when you are developing the code, not when you ship it - + you can use implement a hybrid build process by listing + the production source files into a javac-compliant argfile, + and the development source files in another ajc argfiles: + + + -- file "production.lst": + One.java + two/Three.java + ... + + -- file "tracing.lst": + trace/Library.java + Trace.java + + -- file "development.lst": + @production.lst + @tracing.lst + + + Then your development build can use ajc: + + + ajc @development.lst + + + And your development build can use + ajc or javac + or jikes: + + + jikes @production.lst + + + + + + What plans are there to support my IDE? + + + + The AspectJ team directly provides components for JBuilder, Forte, + and Emacs. We also support the open-source AspectJ plugin project + at http://eclipse.org/ajdt + which uses the AJDE API support for IDE's. We + are interested in supporting other developers as they use AJDE + to provide components for the following IDE's (roughly in + order of interest and viability). + + + + IDEA/IntelliJ has an enthusiastic community and + the developers are working on an extensibility API + - http://intellij.com + + + + jEdit comes from a very active open-source community. + + + + Oracle JDeveloper has an Extension SDK unfamiliar to us. + + + + Together extensibility API is too limited + + + + VisualCafe may have a difficult extensibility API + + + + + IBM's VisualAge for Java is to be replaced with Eclipse + + + + Some have suggested Codeguide from Omnicore + http://www.omnicore.com/ + + + Visual SlickEdit ?? + Kawa has been discontinued + VIM has been suggested. + + + + If you would like to build support for an IDE, contact us so we can help. + To contribute or propose new IDE's, please + mail us. + + + + + + Can I port AJDE support to my development environment? + + + Yes. The core AJDE API is extensible and the source code is + available for download. Start by studying the sources + for the existing IDE support. + + + + + + Programming notes and tips + + + Is it possible to change methods by introducing keywords (like + synchronized), adding parameters, + or changing the "throws" clause? + + + + AspectJ does not enable you to change the signature of a method, + but you can (by express declaration) work around some + limits imposed by the signature. You can convert a checked exception to + unchecked using declare soft, privileged aspects + have access to private methods, and you can use a percflow aspect to + ferry additional state to a callee without changing intervening + signatures. For more details, see + The AspectJ Programming Guide. + In the case of synchronized, + we have what we consider a better solution that uses + around advice instead of introduction. This solution is described + in + + this thread + on the AspectJ users list, with some + + additional comments + . + + + + + + + I don't understand what join points exist. How can I see them? + + + + + Try using an aspect posted to the user's list called + + TraceJoinPoints.java + . + For example, you can start logging at a particular method call and + see what join points occur after the call and before it returns. + + + + + + + What is the difference between call and execution join points? + + + + Consider method execution in Java as (1) the initial call from + this object to some method on the target object with a + particular signature; and (2) the execution of the actual code + in the particular method dispatched in the target object. + The call join point starts with the initial call and ends + when control returns to the call (by return or perhaps + thrown exception). The execution join point starts with + the method body and ends when the body completes (again + by return or throwing an exception), so the execution join + point always happens within the bounds of the corresponding + call join point. You can see this if you use the + join-point tracing aspect in + + TraceJoinPoints.java + . + as described above. + + As you would expect, the context differs + in advice on pointcuts picking out execution and call join + points; for call, this refers to the caller, whereas + for execution this refers to the called + (executing) object. + + + There are some subtle interactions with other AspectJ semantics. + First, the meaning of the signature in the + execution() and call() + pointcut designators (PCD's) differ: the call type depends upon + the type of the reference making the call, while the execution + type depends on the enclosing class. + Second, you may choose one over another if you cannot bring all + your sources within the code the compiler controls + (described in the appendix + to the Programming Guide). + For example, to trace calls into a + method from classes which are outside the code the compiler controls + at compile time, then using execution() will work + while using call()may not. Finally, since + super invocations are not considered method calls, + to trace super.foo() would require using + execution. + + + In most cases you should use the call() + pointcut designator unless you have a good reason to use + execution() + + + + + + + What is the difference between cflow and cflowbelow? + + + + + Both pick out all the join points in the control flow of + the specified join points. + They differ only in that the cflowbelow() + pointcut designator does not pick out the join points + specified, while cflow() does. + + + + + + + What is the difference between call and execution? + + + + + There are two interesting times when a constructor or method is + run. Those times are when it is called, and when it actually + executes. + + + The main difference is that a call join point happens outside of + the object (for non-static methods) or class (for static methods + and constructors), and that an execution join point happens inside + the object or class. This means that the within + and withincode pointcuts pick them out + differently: A call join point is picked out within the caller, + while an execution join point is picked + out where it is actually defined. + + + A call join point is the ``outermost'' join point for a particular + call. Once a call join point proceeds, then a number of different + things happen. For non-static methods, for example, method + dispatch happens, which will cause one method execution join point + -- perhaps more, if there are super calls. For constructors, the + super constructor is called, and fields are initialized, and then + various constructor execution join points will occur. + + + A call join point matches only the ``external'' calls of a method + or constructor, based on a signature, and it does not pick out + calls made with super, or + this constructor calls. + + + + + + How do I say that I want the topmost entrypoint in a + recursive call? How about the most-recent prior entrypoint? + + + + This is best seen by way of example. + Given a recursive call to int factorial(int) + you can print the arguments for + (a) the current and most-recent recursive call + or (b) the current and original recursive call: + + +aspect LogFactorial { + pointcut f(int i) : call(int factorial(int)) && args(i); + + // most-recent + before(int i, final int j) : f(i) && cflowbelow(f(j)) { + System.err.println(i + "-" + j); + } + + // original + before(int i, final int j) : f(i) + && cflowbelow(cflow(f(j)) && !cflowbelow(f(int))) { + System.err.println(i + "@" + j); + } +} + + + + + + What is the difference between constructor call, + constructor execution, initialization, and static + initialization join points? + + + + Static initialization pertains to initialization of + a class or interface type. Constructor call and execution + are akin to method call, and initialization generalizes this and + picks out the first constructor called. + + Their relations are best + demonstrated by tracing the join points. Below is the class + Test which implements an interface and extends a class + along with a trace of the join points below and including + the constructor call obtained using + TraceJointPoints.java (linked above). + + + + + + + + + + + + + + + + + + +]]> + + + Ordinarily, using a call pointcut designator + is best because the call join point surrounds the others, but in + the case of constructors there is no target object for + the call (because it has not been constructed yet), so you + might prefer to use the initialization + pointcut designator. + + + + + + + I want advice to run at two pointcuts, but it doesn't run at all. What gives? + + + + + This reflects both a conceptual error and a programming mistake. + Most likely you want to do something like "run the advice for all + public and private calls," and the code looks something like this: + + + within(com.xerox.printing..*) && call(public * *(..)) && call(private * *(..)) + + + A pointcut picks out join points; it is evaluated at each join point. + The expression above would never pick out any call join point, + because no method signature has both public and private access. + In a pointcut, pc1() && pc2() means both + must be true at a given join point for advice to run at that join point. + The correct pointcut would use || as follows: + + + within(com.xerox.printing..*) && (call(public * *(..)) || call(private * *(..))) + + + Then the advice will run at the join point. + + + + + + + How do I refer to a static field when my advice crosscuts multiple classes? + + + + There is no way in advice to refer to the type of the + code executing in a static context except by specification. + This makes it impossible to refer to static members using + runtime information. + + + + + + I would like to reuse a type pattern, e.g., to + write advice that is limited to a certain set of classes. + Do I have to retype it each time? + + + + No. You can declare that all the types implement + an interface you define, and then use the interface type in + your program. For example: + + +/** + * Example of using an interface to represent a type pattern. + * sub-aspects use declare parents to add to traced types, e.g., + * declare parents: com.mycompany.whatever..* implements Marked; + */ +abstract aspect MarkerExample { + /** marker interface for types that we want to trace */ + interface Marked {} + + /** calls to an instance of Marked not from an instance of Marked */ + pointcut dynamicCallsIn(): call(* *(..)) && target(Marked) && !this(Marked); + + /** calls to methods defined by a subtype of Marked + * that don't come from the body of a subtype of Marked + */ + pointcut staticCallsIn(): call(* Marked+.*(..)) && !within(Marked+); + + /** print dynamic calls */ + before(): dynamicCallsIn() { System.out.println("before " + thisJoinPoint); } +} + +aspect MyMarker extends MarkerExample { + declare parents: com.mycompany.whatever..* implements Marked; +} + + + + + + Where do I find example programs? + + + Some examples are distributed in the documentation release, + and you can find other code in the discussions on the users list. + + + + + + Are aspect libraries available? + + + Some libraries are distributed in the release under the + examples folder in the distribution. If you develop a library and + want to make it available to other users, make sure to + + contact us + . + + + + + + How does ajc interact with the + serialVersionUID? + + + + The current version of ajc can change the + serialVersionUID of generated + .class files as a result of weaving in advice. + This is an important fact that developers using both aspects and + serialization should be aware of. It is likely that a future + version of the compiler will be better behaved regarding the + serialVersionUID. + + However, changes to the serialVersionUID + attribute are typically only important when using serialization for + the long-term persistence of objects. Using standard Java + serialization for long-term persistence has a number of drawbacks + and many developers already use alternative solutions. For one + possibly standard solution, see + + Lon + g-Term Persistence for JavaBeans Specification + . + + + + + + How can I use AspectJ with applets? + + + + Just include the aspectjrt.jar as a required archive. + For example, here is the HTML code for an HTML editor + applet that contains some debugging aspects: + + + + + + + + +]]> + + + The above markup has worked reliably with the Java Plugin + (included in the JRE 1.4.x) in IE 6, Mozilla 1.1 (Win32), + and Mozilla 1.0.1 (Red Hat Linux 8.0). + The following link describes how to configure Mozilla/Netscape + 6.x/7.x to use the Java Plugin from a JRE/SDK installation: + + http://java.sun.com/j2se/1.4.1/manual_install_linux.html. + (Thanks to Chris Bartling for this answer.) + + + + + + How can I specify types for advice that captures primitives, void, etc.? + + + + In some cases, AspectJ allows conversion from values of primitive types to Object, + so that highly polymorphic advice may be written. This works if an advice parameter + or the return type for around is typed to Object. So: + + +class Test { + static int i; + public static void main(String[] args) { + i = 37; + } +} + +aspect TraceSet { + before(Object val): set(* Test.*) && args(val) { + System.err.println(val); + System.err.println(val.class); + } +} + + + will print out + + +37 +java.lang.Integer + + + For more information, see the Programming Guide + + semantics section "Context Exposure" + . + + + + + + Common Problems + + + When I run, I get a StackOverflowError + (or a long stack trace or no output whatsoever) + + + + Most likely this is a case of infinite recursion, + where advice is advising itself. It presents as a + StackOverflowError + or silence as the VM exhausts itself in the recursion. + + Of course, infinite recursion is possible in Java: + +public class Main { + public static void main(String[] args) { + try { + main(args); + } finally { + main(args); + } + } +} + + If you compile and run this program, and it will fail silently, trying + to process the finally clause even after throwing the StackOverflowError. + + Here's a similar AspectJ program where the recursion is + not so obvious: + + +aspect A { + after(): call(* *(..)) { System.out.println("after " + thisJoinPoint); } +} + + This re-invokes itself because it advises any call. + It invokes itself even after an exception is thrown, since + after advice, like a finally clause, runs even + after exceptions are thrown. You can fix this by following two practices: + + + (1) Use after returning to advise normal completions + or after throwing to advise abrupt completions. + If you use after or after throwing, + write the advice with the same care you would a finally clause, + understanding that it may run after some failure. + + (2) Avoid writing advice that advises itself. One simple way to + do so is to exclude the code within the current aspect: + + +aspect A { + after() returning: !within(A) && call(* *(..)) { + System.out.println("after " + thisJoinPoint); + } +} + + A better way is often to re-write the pointcut. + If the advice is advising itself accidentally, that's a sign that + the pointcut is not saying what you mean. + + +aspect A { + pointcut withinTargetClasses() : within(A+) || within(B+); + after() returning: withinTargetClasses() && call(* *(..)) { + System.out.println("after " + thisJoinPoint); + } +} + + + + + + I've declared a field on every class in + my package; how do I use it in advice? + + +aspect A { + boolean com.xerox..*.dirtyFlag; + after (Object target) returning + : target(target) && call(* com.xerox..*.set*(..)) { + target.dirtyFlag = true; // compile fails here + } +} + + + + You need a type to refer to any member, field or method. + It's generally better to introduce onto an interface and + declare classes to implement the interface, which permits you + to use the interface type in advice formals. + + +aspect A { + interface TrackingSets {} + boolean TrackingSets.dirtyFlag; + declare parents : com.xerox..* implements TrackingSets; + + after (TrackingSets target) returning + : target(target) && call(* com.xerox..*.set*(..)) { + target.dirtyFlag = true; + } +} + + + + + + The AspectJ compiler aborts with an OutOfMemoryError when + compiling many classes. How can I fix this? + + + + The command ajc is actually a script that + launches a Java virtual machine with the correct classpath. You + should make a copy of this script, rename it, and then edit it. + Change the -Xmx option, size of memory allocation pool (heap). You + might try -Xmx128M or even + -Xmx256M. + + + + + + + ajc recompiles all files every time. + How can I make it recompile only the files that have changed? + + + + + ajc 1.0 does not currently support incremental + compilation, but we are working on this for the 1.1 release. + + As a limited workaround, many build systems enable you to avoid + doing a compile if no sources have changed. (See, e.g., Ant's + "uptodate" task.) + + + + + + + ajc is using the wrong JVM. How do I + fix it? + + + + The easiest way to fix this is to re-install + ajc (using the same .class or + .exe file that you originally downloaded) and + this time make sure to tell it to use the desired JDK (typically + the JDK versions 1.2 or 1.3 from Sun). + + If you are familiar with DOS batch files or shell programming, + you could also fix this by simply editing the + bin\ajc.bat or bin/ajc + script. + + + + + + My IDE is trying to parse AspectJ files which makes my project unusable. + What can I do? + + + + + When working with an unsupported IDE that objects to the syntax of + AspectJ source files (and, e.g., automatically gathers them + in a source tree as Java files based on the .java extension), + you can use the .aj extension for your AspectJ files. + The ajc compiler accepts both .java and .aj files, and you can + set up your build scripts to include the correct list of + source files. (You will have to find another editor for + editing AspectJ files; you can use the ajbrowser to view + edit your AspectJ files and navigate the crosscutting structure.) + + + + + + I used to be able to compile my program in my IDE, but when I + use AJDE, I run out of memory (or it goes really slow). + + + + + The ajc compiler does more analysis than (e.g.,) javac, + and AJDE may in some IDE's hold a copy of the structure tree until the + next tree is available from the compile process. Both mean that you may + need extra memory to compile the same program. However, increasing + available memory to the point that you are swapping to disk can + slow the process considerably. + + + If you are having problems and would like to find the optimal memory + allocation, iteratively decrease the amount of memory available until + AJDE or ajc signals out-of-memory errors, and then increase that + amount by 5-10%. + + + To increase memory for the ajc compiler, see . + For your IDE, do something similar or follow the provider's instructions. + For example, to increase memory in JBuilder, edit the + jbuilderX/bin/jbuilder.config + file to have an entry like: + +vmparam -Xmx384m + + + + If it turns out that your project is too big to use with AJDE, your IDE + may nonetheless support external commands or Ant build processes, which + run outside the IDE memory space. For an Ant taskdef, see + . For a JBuilder Ant plugin, some + people have directed us to . + + + + + + + My stack traces don't make sense. What gives? + + + + Unless you are using the ajdb debugger, + stack traces may + have synthetic methods in the stack, and the line numbers may + not track your source code. The + Development Environment Guide. + discusses how to interpret stack at the end of the section + on the ajc compiler. + + + + + + + My advice is not running (or running twice), and I don't know why. + + + + When advice is not running, it is probably a problem in the + pointcut. Sometimes users specify pointcuts that do not mean what they intend - + most often when they misspell a type name. Run the compiler in + -Xlint mode, which will flag some likely mistakes, + like the type name. If that does not work, use + + TraceJoinPoints.java + to see if your join points are executing at all. + + When advice is running more than it should, it may be that your + pointcut picks out more join points than you intend. + If you are using IDE support, you should be able to trace back from + the pointcut or advice to the join points which can be statically + determined to be affected. To identify advised dynamic join points, + you can try using + + TraceJoinPoints.java + , but often it is easier to update the advice to + print the source location of the join point. + This will show if the advice applies to code that you did + not consider. + + If you've done this and convinced yourself it's not working, + it may be a bug. See . + + + + + + + I declared a member on a class with package access, but other classes in the package cannot see it. + + + + When declaring parents on other types from an aspect, package access only + applies to code the implementation controls. For AspectJ 1.0, that is the set of files + passed to the compiler. That means other classes not compiled with the aspect will not + be able to access the aspect-declared members even if they are in the same package. + The only way for classes outside the control of the implementation to access aspect-declared + members is to declare them public. + + + + + + + ajc complains that it can't find + javac. What's wrong? + + + + + ajc does not try to locate + javac in your path: it uses the + javac classes directly. In JDK 1.2 and 1.3 these + classes are found in tools.jar (in the + lib directory of the JDK distribution), which + must be on your classpath to make + ajc work with javac. + Inspect the java command that launches ajc to make sure that + tools.jar is on the classpath for ajc; + the -classpath option only applies to the sources compiled. + + + + + + + I'm running under 1.4, but ajdoc asks for 1.3 + (or throws IllegalAccessError for HtmlWriter.configuration) + + + + + The current implementation of ajdoc uses + specific javadoc classes in the J2SE 1.3 tools.jar. + We are working on addressing this limitation, but in the interim + it is best to run ajdoc under 1.3. + + + When running from the command-line scripts, edit the scripts directly + to put the 1.3 tools.jar first on the classpath. (The installer does + not know about this limitation of ajdoc.) + + + When running from Ant, users often have tools.jar in ${ant.classpath} + (to make javac, et al work). That makes it impossible to run the ajdoc + taskdef (which does not currently support forking), so you'll need to + run a separate ant process, either from the command-line or via Ant's + exec task (the Ant task will propagate the classpath). + If the wrong tools.jar is not on the ant classpath, then it should work + to put the 1.3 tools.jar in the taskdef classpath. + + + + + + I set up different files to my compiles to change what + the aspects see, but now I don't + understand how the aspects are working. + + + + It is a bad practice to use the compilation unit + to control crosscutting. Aspects and pointcuts especially + should be written to specify crosscutting precisely. + Aspects will behave the same when you add files if + you initially included all files affected by your aspects. + If you use the compilation unit, then your code will behave + differently in AspectJ implementations that do not limit + themselves to specified files. + + + + + + I'm reading the code generated by ajc + in -preprocess mode, and it seems like it would not + work (or "like it works this way"). + + + + The generated code can be difficult for a human to read and + understand. The compiler uses implementation techniques which might + not be apparent. To determine if the code is behaving correctly, you + should write and run a program that attempts to provoke the error you + suspect. Similarly, you should not rely on invariants you infer from + the generated code (especially naming conventions for generated members). + Please rely only on the semantics stated in the appendix of the + AspectJ Programming Guide. + + + + + + I've heard AspectJ can generate or inject code into my code. + Is this true? + + + + + This is a misconception spawned from the early implementation. + + + AspectJ does not "inject" or "generate" code. In AspectJ the + pointcut constructs allow the programmer to identify join points, + and the advice constructs define additional code to run at those + join points. + + + So the semantic model of advice is like the semantic model of a + method -- it says "when any of these things happen, do this". + + + People who worked with earlier versions of AspectJ, in which ajc + was very explicitly a pre-processor, sometimes thought of AspectJ + as injecting code. But that was an artifact of the implementation, + not the underlying language semantics. + + + This distinction is important for two reasons. One is that thinking + about it this way will make more sense at the implementation continues + to evolve towards load-time or runtime weaving. The other is that + it makes it much easier to understand the semantics of advice on + cflow pointcuts. + + + + + + What are the bugs now most affecting users? + + + + + + 813 + - Ajdoc requires J2SE 1.3 tools.jar, not that of 1.2 or 1.4. + + + + + + + + Getting Help + + + + How do I find out more about AspectJ? + + + + Visit the AspectJ project web site: + http://aspectj.org. + + + + + + How do I submit a bug report? + + + You can submit a bug using the web interface + http://aspectj.org/bugs + (preferred), or you may send email to + jitterbug@aspectj.org directly. + See also + +If it seems to be a bug in the compiler, + please include in the body of the email source code to reproduce the problem. + + + + + + + How do I submit comments and feature requests? + + + + You can email comments to all users at + users@aspectj.org, + email the AspectJ team at + support@aspectj.org. + You can view and submit bug reports and feature requests at + http://aspectj.org/bugs. + If you think you might simply be making a mistake, you might + email some source code to + users@aspectj.org. + + + + + + + How do I communicate with other AspectJ users? + + + + You can reach other AspectJ users by using the + aspectj-users mailing list. To subscribe to the list or view the + list archives go to the user community page: + + http://aspectj.org/lists + . + + + + + + + How can I search the email archives or the web site? + + + + + There is a search entry box on the left navigation bar of the web site, + but it is generally more effective to do a google search of the form, + + http://www.google.com/search?q=site%3Aaspectj.org+%22abstract pointcuts%22 + + + + + + + + How should I write email queries? + + + + + + + Here's the big picture of what I'm trying to do... + + + + + Here's what I think it takes, in AspectJ terms + (concepts, syntax, and semantics) from the + Programming Guide... + + + + + Here's the AspectJ code I'm using, the output it + produces when run, and what I expect... + + + + + The big picture helps others redirect you to other approaches. + Using AspectJ terms helps others correct mistakes in thinking + about the problem (the most common being to confuse join points + and pointcuts). + The code is key to clarifying your question and getting a good + response. On the mail list, someone can reply by fixing your + code. In bugs, the developers can reproduce the problem immediately + and start analyzing the fix. + + + For the mail lists, we try to follow the conventions for open-source + discussions that help avoid "the tragedy of the commons." + For example conventions, see + + http://jakarta.apache.org/site/mail.html + and + + http://www.tuxedo.org/%7Eesr/faqs/smart-questions.html + . + + + + + + + How do I write bugs for IDE support? + + + + + Bugs appearing in the IDE's may apply to the affected IDE + or to the compiler. Compiler stack traces in IDE message windows + are prefixed "Internal Compiler Error" and should be written up + as compiler bugs. If you are unsure, try redoing the compile + from the command line. + + + Bug reports for the Eclipse support go to the Eclipse + + bugzilla + database. + Bug reports on other IDE support should have version + information for both Java and the IDE, and + (most importantly) clear steps for reproducing the bug. + You may submit the bugs via the web form + (http://aspectj.org/bugs) + or via email + (jitterbug@aspectj.org). + + + One of the benefits of open-source is that you can + find and fix the bug for yourself; when you submit + the fix back to us, we can validate the fix for you + and incorporate it into the next release. Email + support@aspectj.org + for instructions on submitting a patch. + + + + + + + How do I write bugs for the AspectJ compiler? + + + + + The best compiler bug report is a reproducible test case, + standalone code that demonstrates the problem. + Sometimes with aspects, a test case requires several + files, if not some way to capture the behavior. + Here's how we recommend submitting test cases: + + + + Write the test case so that when the compiler bug + is fixed, the test completes normally without output + (e.g., expected compiler errors are issued, + or classes produced run correctly). This usually + means writing one or more source files. + + + + + In the bug report, briefly summarize the bug. + If it is not obvious, be sure to specify + the expected output/behavior (e.g., compiler error on line 32) + and, if the compile should complete, the main class to run. + + + + + At the end of the report, append each source file, + separated with a line and the file name. + (Include all sources, and do not send attachments.) + + + + + Submit the bugs via the web form + (http://aspectj.org/bugs) + or via email + (jitterbug@aspectj.org). + + + + + + + + + + Can you recommend reading or teaching material for AspectJ? + + + + The documentation available on this site is a primary source of + material on AspectJ: + + + + + + + Selected AspectJ Papers and Presentations + + + Papers presented at various conferences; tutorial + slide presentations. + + + + + + Aspect-Oriented Programming + + + + The seminal AOP/AspectJ paper + + + + + + The AspectJ Programming Guide + + + A practical guide for programmers. + Includes a number of examples, some quite + sophisticated. + + + + + The AspectJ Tutorial + + Slides from a day-long tutorial presentation on + AspectJ. + + + + + + + + + + + + Where can our group get consulting and support? + + + + Beyond what's available on the aspectj.org web site, + the AspectJ team does a limited amount of consulting + and support for qualified groups. For more information, + see . + + + + + + + What has changed since the last FAQ version? + + + + + Entries changed since the earlier September 13 version: + + + + + + + + + + + + + + + + + + + + + + + About the AspectJ Project + + + What does the fact that AspectJ is an Open Source + Project mean to me? + + + + Open source protects your interest in a correct, long-lived, + up-to-date, and widely-accepted implementation of AspectJ. + + + With the source code, you control your own destiny + in perpetuity. You can continue to use the implementation + and update it as necessary to fix bugs and add things you need. + + + + Because the code is available to all, anyone can find + and fix bugs. There is no need to hope for it to be fixed + in the next product release. Those who encounter the bugs + are motivated to fix them, and there are more eyeballs on + the code than in closed-source, so the quality tends to be high. + This can be particularly true for the AspectJ community, + which tends to be highly skilled. + + + + The same is true of new features or behavior, so the + implementation should be up-to-date. This is important as + the field of AOP develops, to capture the latest solutions. + + + + For a programming language which forms the basis of + an entire solution stack, open source facilitates the kind + of adoption -- tool integrations and significant projects -- + that develop and prove the technology for wider adoption. This + limits delays caused by waiting for the completion of standards + process or promulgation by industry leaders, and also provides + the proofs necessary for such adoption. + + + + + + + + + What are your plans to make AspectJ a general feature + of Java supported by Sun and the other key players in the Java + Industry? + + + + Although we are committed to making AspectJ available to a wide + range of users, it is too early to decide on a strategy. Some + options include continuing AspectJ as a stand-alone product, + integrating it into IDEs, or possibly incorporating it into + standard Java with Sun's blessing. + + We currently focus on developing for the 1.1 implementation + which improves AspectJ in key areas: rapid + incremental compilation, bytecode weaving, and IDE integration. + + Through all of this our goal is to make AspectJ integrate as + seamlessly as possible with the Java programming language. The + AspectJ language design is becoming more integrated, the compiler + is becoming faster and more integrated, the IDE extensions are + becoming more integrated. All of this is designed to help users + really use AspectJ and give us feedback on it. + + As the system is improved and we work more closely + with users, we will be in good position to explore the best path + for AspectJ in the long term. + + + + + + When will AspectJ work from class files? + When will it work at class-loading time? + + + + Bytecode weaving is scheduled for AspectJ 1.1. We believe it + will work as described in an email to the users list by Jim Hugugin: + + + The AspectJ language was designed to support weaving at many different times: + compile, load, or even run-time in the JVM. Weaving into bytecodes at both + compile and load-time will definitely be provided in a future release. This + will allow weaving at compile-time into libraries for which source code is + not available. It will also support aspect-aware class loaders that can + perform weaving at load time on arbitrary classes. One advantage of a + language like AspectJ, rather than an explicit meta-tool like jiapi, is + that it separates the specification of a crosscutting concern from any + particular implementation strategy for weaving. + + + ...AspectJ provides a language that can cleanly + capture crosscutting concerns while preserving the static type checking, + modularity, and composability of Java. + + If you have an application for using aspects and bytecode, + please let the AspectJ team know of your requirements. + + + + + + What are the differences between the current and + previously released versions of AspectJ? + + + + The AspectJ team aims to keep the implementation up-to-date + and bug-free, but to limit language changes to those that + are carefully considered, compelling, and backwards-compatible, + and to deliver those language changes only in significant releases (1.0, 1.1). + + + + + + + Version + Description + + + AspectJ 1.0 + Many language changes, fixes, cleanup and + clarifications, some significant. + + + + AspectJ 0.8 + More cleanup of the syntax and semantics. + + + AspectJ 0.7 + Clean up of the semantics, 0.7 beta 4 is the first + open source release. + + + + AspectJ 0.6 + Advice and crosscuts get explicit type signatures + which describe the values that are available to advice at a + crosscut. + + + + AspectJ 0.5 + Improved tool support: better Emacs environment + support and ajdoc to parallel + javadoc. around advice is added, and the + aspect keyword is removed and replaced + by the Java keyword class. + + + + AspectJ 0.4 + Clear separation of crosscuts and crosscut actions + makes it possible to define extensible library + aspects. + + + + AspectJ 0.3 + First all Java implementation, also includes many + small language improvements. + + + + AspectJ 0.2 + General-purpose support for crosscutting. Users could + program any kind of aspects, not just coordination. This + release dropped COOL. + + + + AspectJ 0.1 + A single domain-specific aspect language, called COOL, + for programming coordination in multi-threaded + programs. + + + + +

+ More detailed comments are available in the + doc/changes.html file in the + distribution. + + + + + + + What is the AspectJ development schedule? + + + + + The AspectJ Development Schedule + + + + Version + Description + + + 1.0 + Final syntax and semantic changes. Standalone structure + browser. Complete documentation. + + + + 1.1 + Faster incremental compilation, bytecode weaving, + and a small number of language changes. + + + 2.0 + New, dynamic crosscuts (bytecode-only) + + + +

+ + + + + AspectJ is a registered trademark of Palo Alto Research Center, Incorporated (PARC). + Java and all Java-based marks are trademarks or registered trademarks of + Sun Microsystems, Inc. in the United States and other countries. All other + trademarks are the property of their respective owners. + +

See ${installer.output.readme} for more information about +the contents of this package.

The automatic installation process is complete. Press Next for +some final instructions.

Installer for AspectJ(TM) Documentation and Examples

Press Next to continue. At any time you may press Cancel +to exit the installation process.

Please select a directory into which to install the aspectj documentation and +examples. If you've already installed the compiler and core tools, we +recommend that you install the documentation and examples to the same directory +for convenience.

Attribute	Description	Support
encoding	encoding of source files.	Yes?
optimize	whether source should be compiled with optimization	Yes?
target	generate class files for specific VM version (e.g., `1.1` +or `1.2`).	Yes
depend	enables dependency-tracking	No
includeAntRuntime	whether to include the Ant run-time libraries	No
includeJavaRuntime	whether to include the run-time libraries from the +executing VM	No
threads	Multi-threaded compilation	No

Section	Contents
docs	+ FAQ, + Quick Reference, + programming and + development guides, + API and + + (local) + + examples +
distributions	+ compiler, AJDE, docs, and Ant taskdefs + (binary + - source) +
resources	+ aosd.net; + aspectj.org + bug db and + email, + mail lists for + users and + support +
paths	for those new to AspectJ +

+AjcTask Ant Support for AspectJ 1.1

+Description

+Parameters

Parameters supported by ajc

Nested Elements

Programmatically handling compiler messages

+Ajc10 Ant Task

+Description

+Parameters

Parameters supported by ajc

+Parameters that used to be ignored by +the ajc taskdef, but now are supported or cause failures

+Parameters unique to ajc

argfiles - Argument list files

+Parameters specified as nested elements

+src, classpath, bootclasspath and extdirs

+Examples

AspectJ Ant Tasks

About the AspectJ Ant tasks

Installation

4. What to do if you encounter problems

Recent Changes in AspectJ 1.0

AJDE for JBuilder

AJDE for JBuilder

AJDE for Forte/NetBeans

AJBrowser

Incompatible changes

AJDE for JBuilder

AJDE for Forte/NetBeans

AJDE for Emacs

AJDE for JBuilder

AJDE for Forte

AJDE for JBuilder

AJDE for Forte

AJBrowser

Emacs Support: aspectj-mode and AJDEE

AJDE for JBuilder

AJDE for Forte

AJBrowser

Emacs Support: aspectj-mode and AJDEE

AJDE for JBuilder

AJDE for Forte

AJBrowser

Emacs Support: aspectj-mode and AJDEE

AJDE for JBuilder

AJDE for Forte

AJBrowser

Aspectj-mode and AJDEE: AspectJ support in Emacs

AJDE for JBuilder

AJDE for Forte

Aspectj-mode and AJDEE: AspectJ support in Emacs

Pointcuts

Type patterns

Advice

Introduction and static crosscutting

Aspects

Known Limitations

AJDE for JBuilder

Installation

Key Improvements

Known Bugs & Limitations

AJDE for Forte

Installation

Key Improvements

Known Bugs & Limitations

AJDE for Emacs

AspectJ Documentation and Resources

AspectJ documentation

AspectJ distributions

Other AspectJ resources

Suggested paths for those new to AspectJ

Porting Notes

Not exposing state

Exposing state

Constructor receptions

Using args

Rewriting calls

Rewriting gets and sets

Rewriting handlers

Parameters supported by `ajc`

Parameters supported by `ajc`

+Parameters that used to be ignored by +the `ajc` taskdef, but now are supported or cause failures

+Parameters unique to `ajc`

+`src`, `classpath`, `bootclasspath` and `extdirs`