JAVA OLYMPUS.com


aa Contact Us aa Home aa About Us aa Sign Up aa Free Java Books aa Java Books




AOP

   
JAVA 2
Subcategories

JAVA LANGUAGE
   Getting Started
   Java Fundamentals

J2SE
   Annotations
   Applets
   Auto Boxing
   AWT
   Beans
   Collections
   Ennumerated Types
   Exceptions
   Garbage Collection
   Generics
   Immutable Types
   Internationalization
   JNI
   JVM
   I/O
   Logging
   Preference
   Reflection
   Serialization
   RunTime (JRE)
   Threads
  Database Access
   JDBC
   SQLJ
   JDO
  JFC
   J2D
   Drag & Drop
   Swing
  Media
   J2D
   J3D
   JAI
   JMF
   JTAPI
   IMAGE I/O
   SDT
   Sound (JSAPI)
   Speech
  Networking
   CORBA
   JNDI
   IDL
   RMI/IIOP
   Sockets
  Security
   JAAS
   JCE
   JSSE

JINI
   Spaces

OTHER
   Java Agents
   Java Performance
   Java Design
   AOP
   Java Certification


JAVA NETWORK
   JavaOlympus
   J2EEOlympus
   JSPOlympus
   J2meOlympus





AOP banishes the tight-coupling blues Many Java developers have embraced the non-intrusive style and flexibility of aspect-oriented programming (AOP), particularly when it comes to building highly decoupled and extensible enterprise systems. In this article, you'll see for yourself how one of AOP's functional design concepts -- static crosscutting -- can turn what might be a tangled mass of tightly coupled code into a powerful, extensible enterprise application.
Use AOP to maintain legacy Java applications If you've ever inherited and then had to maintain a Java-based legacy application, then this article is for you. Author Abhijit Belapurkar shows you how to use aspect-oriented programming (AOP) to gain an unprecedented view into the inner workings of even the most opaque of legacy applications.
Improve modularity with aspect-oriented programming Aspect-oriented programming (AOP) is a new programming technique that allows programmers to modularize crosscutting concerns (behavior that cuts across the typical divisions of responsibility, such as logging). AOP introduces aspects, which encapsulate behaviors that affect multiple classes into reusable modules. With the recent release of AspectJ by Xerox PARC, Java developers can now take advantage of the modularization AOP can provide. This article introduces AspectJ and illustrates the design benefits that result from its use.
Test flexibly with AspectJ and mock objects Programmers who have incorporated unit testing into their development process know the advantages it brings: cleaner code, courage to refactor, and higher velocity. But even the most die-hard unit testers can falter when faced with testing a class that relies on system state for its behavior. Nicholas Lesiecki, a respected Java programmer and leader in the XP community, introduces the problems surrounding test-case isolation and shows us how to use mock objects and AspectJ to develop precise and robust unit tests.