Spring dependency injection or aspect programming

Question

I have a need for methods in several classes that must always follow a specific pre and post pattern.

public void method(X x, Y y ) {

// ********Repeating Part begin **************/

AFrameworkClass aFrameworkClass = new AFrameworkClass (this.memberVariable,"SomeString");

try {

  aFrameworkClass.aFrameworkMethod( x,y); 
  aFrameworkClass.anotherFrameworkMethod(x,y); 
  aFrameworkClass.yetAnotherFrameworkMethod(x);   
  aFrameworkClass.doPreProcessing(); 

  Throwable t = null ;

// ********Repeating Part End **************/

  try { 
     // code will vary according to the business logic 
  } 
  catch (Throwable t) { 
     // code will vary according to the business logic   
  }

// ********Repeating Part begin **************/

  aFrameworkClass.doPostProcessing();

} finally { aFrameworkClass.doCleanup();

}

// ********Repeating Part End **************/

}

Is it possible to use Spring framework to accomplish the logic in the repeating parts in this method without having to code those lines over and over again in my various classes? If so how?

Answer 1

Absolutely it can be done with Spring's AOP support. You can apply the first part as "before" advice and the 2nd as "after-finally" advice or you can apply both as "around" advice and programmatically invoke the target method like so:

methodInvocation.invoke(); // returns Object

If you want to declare your aspects in XML you can read about how to do it here:

http://static.springframework.org/spring/docs/2.5.x/reference/aop.html#aop-schema http://static.springframework.org/spring/docs/2.5.x/reference/aop.html#aop-schema-advice-before http://static.springframework.org/spring/docs/2.5.x/reference/aop.html#aop-schema-advice-after-finally http://static.springframework.org/spring/docs/2.5.x/reference/aop.html#aop-ataspectj-around-advice

Or if you want to do it with annotations there is info here:

http://static.springframework.org/spring/docs/2.5.x/reference/aop.html#aop-ataspectj

Personally I prefer doing it with XML since the behavior of the aspects can be altered without recompiling the application. Let's say you have a multi-module project where B depends A. A contains reusable advice and is using annotations for order, pointcuts, etc. If you need to change that behavior, you must rebuild A. If you are using XML in project B to configure the aspect from project A, no rebuild of A is needed.

My feeling is that advice is more reusable when you define the behavior in a class and how that behavior is applied in XML.

Answer 2

brd6644 is right, but one thing I've discovered is a problem with Spring AOP is that the advice/advisors cannot be applied to the properties as you are creating the object.

That is, say you have something like

<bean class="...ProxyBeanFactory">
    <property name="target">
        <bean class="myBean">
            <property name="username" value="helloKitty"/>
            <property name="password" value="lkajdahdkahjdkhja"/>
        </bean>
     </property>
 </bean>

It is not possible to write an advisor to decrypt the password for myBean, since the property value is being supplied before the proxy is created. You can't apply the password property to the ProxyBeanFactory class, of course. What you really want to do is have setPassword() called on the object returned from the ProxyBeanFactory with the "lkaj..." argument, but that's not possible, it would seem.

Answer 3

As an alternative to a full-fledged IoC container, you can achieve the same thing using a delegate. Design a base class with the pre- and post- functions and a delegate to inject your varying business logic function. A "RunProcess" base class function would call the pre- operations, the delegate, then the post- operations.