<chapter id="integration">

   <title>Integration With Pointcuts</title>
   <para>
      This docbook has talked a lot about building aspects either with regular aspects, annotations, and introductions.
      This chapter takes a step back and doesn't talk about building aspects, but rather how you can use plain old
      pointcuts in your application to provide logical integration points.
   </para>
   <sect1 id="integration1" revision="1">
      <title>Integration</title>
      <para>
         What you've seen by reading this docbook and the "Reference Manual" on JBoss AOP is that AOP provides a rich
         pointcut expression language that allows you to intercept various points in the Java language.  If you think
         about it, the pointcut language allows you to turn any point in your Java language into an event.  An event
         that can be caught and handled by any piece of code.
      </para>
      <para>
         After productizing and shipping an application, sometimes users want to integrate with such "events".  They
         want to be able to hook into different places of your application so that they can trigger things specific
         to their particular deployment of your product.  Using object-oriented techniques to provide these hooks to users
         would require special gluecode every time a user request like this was made.  Also, as more and more of these
         hooks are exposed through object-orientation, it becomes harder and harder to redesign, refactor, or change
         APIs as the user base is tightly coupled to existing code.
      </para>
      <para>
         This is were AOP and pointcuts come in.  Instead of writing sometimes complicated gluecode, or refactoring
         the application to provide such user-request integration points, the application can provide pointcut
         expressions the user base can use to integrate their specific integration use cases.  The application provides
         logical names to code points as pointcut expressions.  The pointcut expression can change over time as the
         application code is redesigned and/or refactored, but the logical name of the join point/event/integration point
         stays the same and user hooks don't have to change either.  Let's look at an example:
      </para>
      <programlisting>public class BankAccount
{
   public void withdraw(double amount) {...}
}</programlisting>
      <para>
         Let's say the user of this bank account ERP system wanted to have an email sent to the account holder whenever
         a successful withdraw was made.  The ERP system could provide the hook as a pointcut
         and then the user can write an email aspect that binds with this pointcut.
      </para>
      <programlisting><![CDATA[<pointcut name="WITHDRAW" expr="execution(public void BankAccount->withdraw(double))"/>]]></programlisting>
      <para>
         The <literal>BankAccount</literal> class would be instrumented with AOP hooks.  The overhead is quite tiny
         as only an additional boolean expression is needed to instrument this kind of hook.  If the class or method
         name changes, the user integration code is unaffected as they bind their email hook to the logical pointcut
         name.
      </para>
      <para>
         JBoss currently provides integration points in its EJB and MBean layers in such the same way.  Recently,
         BEA Weblogic published AspectJ style pointcuts into the Weblogic runtime so that users could integrate using
         AspectJ.  As AOP becomes more popular you'll see more and more software products offering integration points
         through pointcut expressions.
      </para>
   </sect1>

</chapter>




