DYNAMIC PROXY AND CLASSIC SPRING AOP

Transcription

1 Module 8 DYNAMIC PROXY AND CLASSIC SPRING AOP Aspect-oriented programming (AOP) > Aspect-oriented programming (AOP) is a new methodology to complement traditional object-oriented programming (OOP). > The motivation of AOP is not to substitute for OOP. > AOP is often used together with OOP. > In the world of OOP, applications are organized with classes and interfaces. > These elements are good for implementing the core business requirements, but not the crosscutting concerns

2 Aspect-oriented programming (AOP) > AOP provides another way for developers to organize their application structures. > Instead of the classes and interfaces of OOP, the main programming elements of AOP are aspects. > You may imagine that an aspect modularizes crosscutting concerns like a class modularizes states and behaviors in OOP. Aspect-oriented programming (AOP) > Besides the IoC container, another core module of the Spring framework is its AOP framework. > Currently, there are many AOP frameworks on the market implemented for different purposes and based on different technologies, but only the following three open source AOP frameworks have entered the mainstream: AspectJ, merged with AspectWerkz since version 5 JBoss AOP, as a subproject of the JBoss AS Spring AOP, as part of the Spring framework

3 Spring AOP > AspectJ is the most complete and popular AOP framework in the Java community. > By comparison, Spring AOP is not a competitor of AspectJ to provide another complete AOP implementation. > Its purpose is only to provide an AOP solution that can consistently integrate with its IoC container. > Spring AOP will only handle crosscutting concerns for the beans declared in its IoC container. Spring AOP > The core technology is dynamic proxy. > Although the usage of Spring AOP has changed significantly from version 1.x to 2.x, the implementation technology remains the same. > Spring AOP is backward compatible: you can continue to use your Spring 1.x AOP elements in Spring 2.x. > Spring version 1.x: AOP usage is through a set of proprietary Spring AOP APIs. > Spring version 2.0: AOP usage is through writing POJOs with either AspectJ annotations or XML-based configurations in the bean configuration file.

4 Non-Modularized Crosscutting Concerns > A crosscutting concern is a functionality that spans multiple modules of an application. > This kind of concern is often hard to modularize with the traditional object-oriented approach. public interface ArithmeticCalculator { public double add(double a, double b); public double sub(double a, double b); public double mul(double a, double b); public double div(double a, double b); public interface UnitCalculator { public double kilogramtopound(double kg); public double kilometertomile(double km); ArithmeticCalculatorImpl public class ArithmeticCalculatorImpl implements ArithmeticCalculator { public double add(double a, double b) { double result = a + b; System.out.println(a + " + " + b + " = " + result); public double sub(double a, double b) { double result = a - b; System.out.println(a + " - " + b + " = " + result); public double mul(double a, double b) { double result = a * b; System.out.println(a + " * " + b + " = " + result); public double div(double a, double b) { double result = a / b; System.out.println(a + " / " + b + " = " + result);

5 UnitCalculatorImpl public class UnitCalculatorImpl implements UnitCalculator { public double kilogramtopound(double kilogram) { double pound = kilogram * 2.2; System.out.println(kilogram + " kilogram = " + pound + " pound"); return pound; public double kilometertomile(double kilometer) { double mile = kilometer * 0.62; System.out.println(kilometer + " kilometer = " + mile + " mile"); return mile; Tracing the Methods > A common requirement of most applications is to trace the activities that take place during program execution. > There are several logging implementations available for you to choose. > If you would like your application to be independent of the logging implementation, you can make use of the Apache Commons Logging library. > It provides abstract APIs that are implementation independent and allows you to switch between different implementations without modifying code.

6 Apache Commons Logging library > To use the Apache Commons Logging library, you have to include commons-logging.jar (located in the lib/jakartacommons directory of the Spring installation) in your classpath. > log4j.properties ### direct log messages to stdout ### log4j.appender.stdout=org.apache.log4j.consoleappender log4j.appender.stdout.layout=org.apache.log4j.patternlayout log4j.appender.stdout.layout.conversionpattern= %d{yyyy-mm-dd HH:mm:ss %5p %c{1:%l - %m%n ### set root logger level ### log4j.rootlogger=error, stdout log4j.logger.edu.itu.service=info ArithmeticCalculatorImpl public class ArithmeticCalculatorImpl implements ArithmeticCalculator { private Log log = LogFactory.getLog(this.getClass()); public double add(double a, double b) { log.info("the method add() begins with " + a + ", " + b); double result = a + b; log.info("the method add() ends with " + result); public double sub(double a, double b) { log.info("the method sub() begins with " + a + ", " + b); double result = a - b; log.info("the method sub() ends with " + result); public double mul(double a, double b) { log.info("the method mul() begins with " + a + ", " + b); double result = a * b; log.info("the method mul() ends with " + result);

7 UnitCalculatorImpl public class UnitCalculatorImpl implements UnitCalculator { private Log log = LogFactory.getLog(this.getClass()); public double kilogramtopound(double kilogram) { log.info("the method kilogramtopound() begins with " + kilogram); double pound = kilogram * 2.2; log.info("the method kilogramtopound() ends with " + pound); return pound; public double kilometertomile(double kilometer) { log.info("the method kilometertomile() begins with " + kilometer); double mile = kilometer * 0.62; log.info("the method kilometertomile() ends with " + mile); return mile; Validating the Arguments > Now let s consider adding a restriction to your calculators. > Suppose you would like your calculators to support positive numbers only. > At the beginning of each method, you make calls to the validate() method to check if all the arguments are positive numbers. > For any negative numbers, you throw an IllegalArgumentException.

8 ArithmeticCalculatorImpl public class ArithmeticCalculatorImpl implements ArithmeticCalculator { private Log log = LogFactory.getLog(this.getClass()); public double add(double a, double b) { validate(a); validate(b); log.info("the method add() begins with " + a + ", " + b); double result = a + b; log.info("the method add() ends with " + result); private void validate(double a) { if (a < 0) { throw new IllegalArgumentException("Positive numbers only"); Identifying the Problems: crosscutting concerns > As you can see, the original calculator methods expand as you add more and more non-business requirements, such as logging and validation. > These system wide requirements usually have to crosscut multiple modules, so they are called crosscutting concerns to distinguish them from the core business requirements, which are called the core concerns of a system. > Typical crosscutting concerns within an enterprise application include logging, validation, pooling, caching, authentication, and transaction.

9 Crosscutting Concerns Arithmetic Calculator Unit Calculator... Logging Validation > The traditional object-oriented approach cannot modularize crosscutting concerns well with only classes and interfaces as programming elements. Modularizing Crosscutting Concerns with Dynamic Proxy > You can apply a design pattern called proxy to separate crosscutting concerns from core concerns > The principle of the proxy design pattern is to wrap an object with a proxy and use this proxy to substitute for the original object. > Any calls that were made to the original object will go through the proxy first. Client Target Object

10 LoggingHandler public class LoggingHandler implements InvocationHandler { private Log log = LogFactory.getLog(this.getClass()); private Object target; public LoggingHandler(Object target) { this.target = target; public Object invoke(object proxy, Method method, Object[] args) throws Throwable { log.info("the method "+method.getname()+"() begins with " +Arrays.toString(args)); Object result = method.invoke(target, args); log.info("the method " + method.getname() + "() ends with " + result); Proxy.newProxyInstance public class TestArithmeticCalculator { public static void main(string[] args) { ArithmeticCalculator arithmeticcalculator = new ArithmeticCalculatorServiceImpl(); ArithmeticCalculator calc= (ArithmeticCalculator) Proxy.newProxyInstance( arithmeticcalculator.getclass().getclassloader(), arithmeticcalculator.getclass().getinterfaces(), new LoggingHandler(arithmeticCalculator)); calc.add(1, 2); calc.sub(4, 3); calc.mul(2, 3); calc.div(4, 2);

11 CalculatorValidationHandler public class CalculatorValidationHandler implements InvocationHandler { public static Object createproxy(object target) { return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getclass().getinterfaces(), new CalculatorValidationHandler(target)); private Object target; public CalculatorValidationHandler(Object target) { this.target = target; public Object invoke(object proxy, Method method, Object[] args) throws Throwable { for (Object arg : args) { validate((double) arg); Object result = method.invoke(target, args); private void validate(double a) { if (a < 0) throw new IllegalArgumentException("Positive numbers only"); Validation and Logging Proxies ArithmeticCalculator arithmeticcalculator = new ArithmeticCalculatorServiceImpl(); ArithmeticCalculator calc = (ArithmeticCalculator) LoggingHandler.createProxy(arithmeticCalculator); ArithmeticCalculator proxy= (ArithmeticCalculator) CalculatorValidationHandler.createProxy(calc); proxy.add(-1, 2);

12 Crosscutting Concerns with Classic Spring Advices > Classic Spring AOP supports four types of advices, each of which takes effect at different times of an execution point: Before advice: Before the method execution After returning advice: After the method returns a result After throwing advice: After the method throws an exception Around advice: Around the method execution How It Works: Before Advices public class LoggingBeforeAdvice implements MethodBeforeAdvice { private Log log = LogFactory.getLog(this.getClass()); public void before(method method, Object[] args, Object target) throws Throwable { log.info("the method " + method.getname() + "() begins with " + Arrays.toString(args));

13 How It Works: Before Advices <bean id="loggingbeforeadvice" class="edu.itu.advice.loggingbeforeadvice"/> <bean id="arithmeticcalculatorproxy" class="org.springframework.aop.framework.proxyfactorybean"> <property name="proxyinterfaces"> <list> <value> edu.itu.service.arithmeticcalculator </value> </list> </property> <property name="target" ref="arithmeticcalculator"/> <property name="interceptornames"> <list> <value>loggingbeforeadvice</value> </list> </property> </bean> <bean id="arithmeticcalculator" class="edu.itu.service.arithmeticcalculatorserviceimpl"/> How It Works: Before Advices ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml"); ArithmeticCalculator arithmeticcalculator = (ArithmeticCalculator) context.getbean("arithmeticcalculatorproxy"); arithmeticcalculator.add(2,2);

14 How It Works: After Returning Advices public class LoggingAfterAdvice implements AfterReturningAdvice { private Log log = LogFactory.getLog(this.getClass()); public void afterreturning(object returnvalue, Method method, Object[] args, Object target) throws Throwable { log.info("the method "+method.getname() + "() ends with "+ returnvalue); How It Works: After Returning Advices <bean id="loggingafteradvice" class="edu.itu.advice.loggingafteradvice"/> <bean id="arithmeticcalculatorproxy" class="org.springframework.aop.framework.proxyfactorybean"> <property name="proxyinterfaces"> <list> <value> edu.itu.service.arithmeticcalculator </value> </list> </property> <property name="target" ref="arithmeticcalculator"/> <property name="interceptornames"> <list> <value>loggingbeforeadvice</value> <value>loggingafteradvice</value> </list> </property> </bean>

15 How It Works: After Returning Advices ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml"); ArithmeticCalculator arithmeticcalculator = (ArithmeticCalculator) context.getbean("arithmeticcalculatorproxy"); arithmeticcalculator.add(2,2); How It Works: After Throwing Advices public class ArithmeticCalculatorServiceImpl implements ArithmeticCalculator {... public double div(double a, double b) { if (b == 0) { throw new IllegalArgumentException("Division by zero"); return a/b;

16 How It Works: After Throwing Advices public class LoggingThrowsAdvice implements ThrowsAdvice { private Log log = LogFactory.getLog(this.getClass()); public void afterthrowing(illegalargumentexception e) throws Throwable { log.error("illegal argument"); How It Works: After Throwing Advices <bean id="loggingthrowsadvice" class="edu.itu.advice.loggingthrowsadvice"/> <bean id="arithmeticcalculatorproxy" class="org.springframework.aop.framework.proxyfactorybean"> <property name="proxyinterfaces"> <list> <value> edu.itu.service.arithmeticcalculator </value> </list> </property> <property name="target" ref="arithmeticcalculator"/> <property name="interceptornames"> <list> <value>loggingbeforeadvice</value> <value>loggingafteradvice</value> <value>loggingthrowsadvice</value> </list> </property> </bean>