Enterprise AOP With the Spring Framework

Transcription

1 Enterprise AOP With the Spring Framework Jürgen Höller VP & Distinguished Engineer, Interface21

2 Agenda Spring Core Container Spring AOP Framework AOP in Spring 2.0 Example: Transaction Advice What's Coming in Spring 2.1?

3 Spring Framework (1) Java / J2EE Application Framework originally based on Rod Johnson s book J2EE Design & Development (Wiley, 2002) popularized by "J2EE Development without EJB" (Rod Johnson, Jürgen Höller; Wiley, 2004) Focus on "Plain Old Java Objects" (POJOs) natural component model for applications Open Source Project on SourceForge since February 2003 Apache license >40000 downloads per month

4 Spring Framework (2) Business objects as decoupled POJOs configuration and wiring through framework or usage as normal Java objects independent from the actual environment no unnecessary ties to a framework reusable in any kind of environment in particular: testability in unit / integration tests Generic middleware services e.g. declarative transactions for POJOs flexible alternative to EJB CMT for all applications, including standalone leverage container services when available

5 Core Container (1) "Inversion of Control" configuration and lifecycle of application objects objects do not configure themselves, but get configured from the outside objects don't know the origin of their configuration "Dependency Injection" "setter-based" (JavaBean properties) "constructor-based" (constructor arguments) alternative: "Service Lookup" for example: JNDI

6 Core Container (2) public class ShopFacadeImpl implements ShopFacade { private OrderDao orderdao; private ItemDao itemdao;... public void setorderdao(orderdao orderdao) { this.orderdao = orderdao; public void setitemdao(itemdao itemdao) { this.itemdao = itemdao;... public void insertorder(order order) { this.orderdao.insertorder(order); this.itemdao.updatequantity(order);

7 Core Container (3) Fine-grained externalized configuration representing the internal structure of the application references to other components configuration parameters enables flexible configuration management at fine-grained component level switching between different deployment scenarios XML bean definitions most common configuration format often: separate admin properties file linked into XML bean definitions through placeholders

8 Core Container (4) <bean id="datasource" class="org.apache.commons.dbcp.basicdatasource"> <property name="driverclassname" value="${jdbc.driver"/> <property name="url" value="${jdbc.url"/> <property name="username" value="${jdbc.username"/> <property name="password" value="${jdbc.password"/> </bean> <bean id="orderdao" class="com.myshop.dao.jdbc.jdbcorderdao"> <property name="datasource" ref="datasource"/> </bean> <bean id="petstore" class="com.myshop.service.shopfacadeimpl"> <property name="orderdao" ref="orderdao"/> <property name="itemdao" ref="itemdao"/> </bean>

9 AOP Framework (1) Proxy-based Aspect Orientation proxies for arbitrary POJOs no fixed component model flexible combination of interceptors instance-based AOP Interceptors for Cross-Cutting Concerns actions at beginning/end of method call Caller Target method intercept

10 AOP Framework (2) Do not repeat code: factor out interceptor e.g. logging: configurable trace log e.g. security: authorization checks e.g. common exception handling e.g. transaction demarcation Method interceptor interceptor can be applied to any methods interceptor can be enabled/disabled AOP Alliance: MethodInterceptor interface reuse of pre-built interceptors

11 AOP Framework (3) Custom interceptor implementations rarely necessary, but straightforward usually delegate to target ("proceed") can also abort invocations for example: authorization interceptor public class TestInterceptor implements MethodInterceptor { public Object invoke(methodinvocation inv) throws Throwable { System.out.println("before invocation"); try { return inv.proceed(); finally { System.out.println("after invocation");

12 AOP Framework (4) AOP Framework = creation of proxies build proxy for target object JDK dynamic proxy or CGLIB proxy build interceptor chain between proxy and target according to AOP advice configuration Hooks into Spring's core container FactoryBean or auto-proxy creator core container does not create proxies itself!

13 ProxyFactory ShopFacadeImpl facade = new ShopFacadeImpl(); facade.setorderdao(...); ProxyFactory pf = new ProxyFactory(); pf.settarget(facade); pf.addadvice(new SimpleTraceInterceptor()); pf.addinterface(shopfacade.class); ShopFacade proxy = (ShopFacade) pf.getproxy(); proxy.insertorder(...); // Every call on the proxy will delegate to the target // but first go through the trace interceptor. ProxyFactory pf = new ProxyFactory(); pf.settarget(facade); pf.addadvice(new SimpleTraceInterceptor()); pf.setproxytargetclass(true); ShopFacadeImpl proxy = (ShopFacadeImpl) pf.getproxy(); // Enforce CGLIB proxy that can be cast to the target class!

14 ProxyFactoryBean <bean id="petstoretarget" class="com.myshop.service.shopfacadeimpl"> <property name="orderdao" ref="orderdao"/> <property name="itemdao" ref="itemdao"/> </bean> <bean id="traceinterceptor" class="org.springframework.aop.interceptor.simpletraceinterceptor"/> <bean id="petstore" class="org.springframework.aop.framework.proxyfactorybean"> <property name="target" ref="petstoretarget"/> <property name="interceptornames" value="traceinterceptor"> <property name="proxyinterfaces" value="com.myshop.service.shopfacade"> </bean>

15 AOP in Spring 2.0 Simplified configuration using <aop:*/> tags Closer AspectJ integration pointcut expression language AspectJ-style aspects in Spring aspects in Spring AOP fully interoperable with ajc compiled dependency injection on domain objects

16 Simplified AOP Configuration <aop:config> <aop:advisor id="getageadvisor" pointcut="execution(* *..TestBean.getAge(..))" advice-ref="getagecounter"/> </aop:config> <bean id="getagecounter" class="...countingbeforeadvice"/>

17 AspectJ-style Aspects public class JavaBeanPropertyMonitor { private int gettercount = 0; private int settercount = 0; public void beforegetter() { this.gettercount++; public void aftersetter() { this.settercount++;

18 AspectJ-style Aspects <aop:config> <aop:aspect ref="javabeanmonitor"> <aop:before pointcut="execution(public!void get*())" method="beforegetter"/> <aop:after pointcut="execution(public void set*(*))" method="aftersetter"/> </aop:aspect> </aop:config>

19 @AspectJ-style public class AjLoggingAspect *..AccountService.*(..))") public void public void before(joinpoint jp) { System.out.println("Before " + public void after() { System.out.println("After.");

20 @AspectJ-style Aspects <!-- detects aspects among the bean definitions, and applies them to all other beans in the application context --> <aop:aspectj-autoproxy/> <bean id="aspect" class="demo.ajloggingaspect"/> <bean id="account" class="demo.accountservice"/>

21 Configuration Aspect for Domain public class Account { private AccountService service; public void setaccountservice(accountservice service) { this.service = service; // Automatically injected on 'new'! Account acc = new Account( ); <aop:spring-configured/>

22 Spring 2.0: AOP Unification Same programming model for proxy-based and weaving-based AOP choice of implementation strategies consistent programming model based on AspectJ Typically: start with proxy-based AOP seamlessly works in any kind of ClassLoader environment Use AspectJ compile-time / load-time weaving for more demanding needs with same configuration model

23 Using <tx:advice/> <aop:config> <aop:advisor pointcut="execution(* *..AccountService.*(..))" advice-ref="txadvice"/> </aop:config> <tx:advice id="txadvice" transaction-manager="txmanager"> <tx:attributes> <tx:method name="find*" read-only="true"/> <tx:method name="save*"/> </tx:attributes> </tx:advice> <bean id="txmanager" class="org.springframework.transaction.jta. JtaTransactionManager"/>

24 @Transactional Java 5 annotation for tx demarcation available since Spring 1.2 public class AccountService = true) public List<Account> findaccounts(...) public void saveaccount(account account) {...

25 <tx:annotation-driven/> <!-- automatically detects annotated beans --> <tx:annotation-driven transaction-manager="txmanager"/> <bean id="txmanager" class="org.springframework.transaction.jta. JtaTransactionManager"/> <!-- proxied: allowed to on public, externally called methods only --> <bean id="accountservice" class="demo.accountservice"/>

26 AspectJ AnnotationTransactionAspect <!-- configures AspectJ transaction aspect --> <bean id="txaspect" class="org.springframework.transaction.aspectj. AnnotationTransactionAspect" factory-method="aspectof"> <property name="transactionmanager" ref="txmanager"/> </bean> <bean id="txmanager" class="org.springframework.transaction.jta. JtaTransactionManager"/> <! weaved: allowed to on any methods --> <bean id="accountservice" class="demo.accountservice"/>

27 AspectJ Class Weaving How does the AnnotationTransactionAspect on the previous slide get applied? We configured the aspect, but how does it kick in? Option 1: compile-time weaving AccountService class statically weaved using the AspectJ compiler Option 2: load-time weaving on-the-fly weaving of classes when they get loaded into a Spring application context driven by AspectJ's META-INF/aop.xml Spring 2.0: need to use AspectJ VM agent

28 What's Coming in Spring 2.1? Support for Spring-driven AspectJ load-time weaving through Spring's LoadTimeWeaver abstraction same as used for JPA (Java Persistence API) entity weaving for any supported platform generic Spring VM agent, various application servers "beanname" pointcut element in AspectJ-based pointcut expressions as a custom extension element matching specific beans by name rather than by type leverage availability of named beans in Spring

29 Summary Spring 2.0 offers broad AOP support, integrated into its core container proxy-based pre-built AOP Alliance MethodInterceptors AspectJ-style aspects note: public, externally called methods only! weaving-based standard AspectJ aspects supports private, internally called methods too however: requires weaving infrastructure Typical usage: middleware aspects transaction management statistics, event notification, etc

30 And of course... we'll be happy to assist you! Interface21 Spring from the Source Spring Training: e.g Frankfurt... or in-house Quick Scan: How can Spring help you? Support contracts for Spring