Aspect oriented programming_with_spring
-
Upload
guo-albert -
Category
Education
-
view
3.071 -
download
0
Transcript of Aspect oriented programming_with_spring
![Page 1: Aspect oriented programming_with_spring](https://reader035.fdocuments.net/reader035/viewer/2022081400/555a7845d8b42abb628b45a7/html5/thumbnails/1.jpg)
Aspect Oriented Programming
with
Spring
![Page 2: Aspect oriented programming_with_spring](https://reader035.fdocuments.net/reader035/viewer/2022081400/555a7845d8b42abb628b45a7/html5/thumbnails/2.jpg)
Problem areaProblem area
• How to modularize concerns that span multiple classes and layers?
• Examples of cross-cutting concerns:– Transaction management– Transaction management– Logging– Profiling– Security– Internationalisation
![Page 3: Aspect oriented programming_with_spring](https://reader035.fdocuments.net/reader035/viewer/2022081400/555a7845d8b42abb628b45a7/html5/thumbnails/3.jpg)
Logging: A naive approachLogging: A naive approach
public class HibernateEventDAO{
private static Log log = LogFactory.getLog( HibernateEventDAO.class );Retrieving log p g g g y g g( );
public Integer saveEvent( Event event ){
log.info( ”Executing saveEvent( Event ) with argument + ” event.toString() );
instance
Logging methodSession session = sessionManager.getCurrentSession();
return (Integer) session.save( event );}
Logging methodexecutions
public Event getEvent( Integer id ){
log.info( ”Executing getEvent( int )” );
Session session = sessionManager.getCurrentSession();
return (Event) session.get( Event.class, id );}
![Page 4: Aspect oriented programming_with_spring](https://reader035.fdocuments.net/reader035/viewer/2022081400/555a7845d8b42abb628b45a7/html5/thumbnails/4.jpg)
Logging: A naive approachLogging: A naive approach
EventManager Service layerInvokes methods onthe DAOs
DAOs perform
(method invocation)
EventDAO Persistence layerPersonDAO
DAOs performboth logging and
persistence operations
![Page 5: Aspect oriented programming_with_spring](https://reader035.fdocuments.net/reader035/viewer/2022081400/555a7845d8b42abb628b45a7/html5/thumbnails/5.jpg)
Shortcomings of naive approachShortcomings of naive approach
• Mixes persistence and logging functionality– Violates the principle of separation of concerns
Increases complexity– Increases complexity
• Involves repetition of codeInvolves repetition of code– Violates the DRY principle– Makes it difficult to change
• Couples the LogFactory to the HibernateEventDAO– Prevents loosely coupled design– Makes re-use and testing problematic
![Page 6: Aspect oriented programming_with_spring](https://reader035.fdocuments.net/reader035/viewer/2022081400/555a7845d8b42abb628b45a7/html5/thumbnails/6.jpg)
Logging: The AOP approachLogging: The AOP approach
EventManager Service layer
Intercepts method(method invocation)
AOP interceptor
invocations andperforms logging
EventDAO Persistence layerPersonDAODAOs perform persistence only
![Page 7: Aspect oriented programming_with_spring](https://reader035.fdocuments.net/reader035/viewer/2022081400/555a7845d8b42abb628b45a7/html5/thumbnails/7.jpg)
Advantages of AOP approachAdvantages of AOP approach
• Separates persistence and logging functionality– The logging concern taken care of by the interceptor
Decreases complexity– Decreases complexity
• Promotes code reuse and modularizationPromotes code reuse and modularization– The AOP interceptor is used by all methods in the DAOs– Makes it easier to change
• Decouples the LogFactory from the DAO impl’s– The HibernateEventDAO is unaware of being logged– Makes re-use and testing simple
![Page 8: Aspect oriented programming_with_spring](https://reader035.fdocuments.net/reader035/viewer/2022081400/555a7845d8b42abb628b45a7/html5/thumbnails/8.jpg)
Aspect Oriented ProgrammingAspect Oriented Programming
• Definition: Enables encapsulation of functionality thataffects multiple classes in separate units
• Complements object oriented programming
• Most popular implementation for Java is AspectJ– Aspect oriented extension for JavaAspect oriented extension for Java– Available as Eclipse plugin and standalone IDE
![Page 9: Aspect oriented programming_with_spring](https://reader035.fdocuments.net/reader035/viewer/2022081400/555a7845d8b42abb628b45a7/html5/thumbnails/9.jpg)
Spring overviewSpring overview
![Page 10: Aspect oriented programming_with_spring](https://reader035.fdocuments.net/reader035/viewer/2022081400/555a7845d8b42abb628b45a7/html5/thumbnails/10.jpg)
AOP with SpringAOP with Spring
• The AOP framework is a key component of Spring
Ai t idi i t ti b t AOP d I C• Aims at providing integration between AOP and IoC
• Integrates but doesn’t compete with AspectJ• Integrates – but doesn t compete – with AspectJ
• Provides two techniques for defining aspects:• Provides two techniques for defining aspects:– @AspectJ annotation– XML schema-based
![Page 11: Aspect oriented programming_with_spring](https://reader035.fdocuments.net/reader035/viewer/2022081400/555a7845d8b42abb628b45a7/html5/thumbnails/11.jpg)
AOP conceptsAOP concepts
• Aspect– A concern that cuts across multiple classes and layers
• Join point– A method invocation during the execution of a programet od ocat o du g t e e ecut o o a p og a
• Advice– An implementation of a concern represented as an interceptor
• Pointcut• Pointcut– An expression mapped to a join point
![Page 12: Aspect oriented programming_with_spring](https://reader035.fdocuments.net/reader035/viewer/2022081400/555a7845d8b42abb628b45a7/html5/thumbnails/12.jpg)
@AspectJ support@AspectJ support
• Style of declaring aspects as regular Java classes withJava 5 annotationsR i tj d tj t th l th• Requires aspectjweaver and aspectjrt on the classpath
• Enabled by including the following information in theSpring configuration file:Spring configuration file:
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:aop="http://www.springframework.org/schema/aop"xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsdhttp://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">
<aop:aspectj-autoproxy/>
![Page 13: Aspect oriented programming_with_spring](https://reader035.fdocuments.net/reader035/viewer/2022081400/555a7845d8b42abb628b45a7/html5/thumbnails/13.jpg)
Declaring an aspectDeclaring an aspect
• A concern that cuts across multiple classses and layers
import org.aspectj.lang.annotation.Aspect;
@Aspectpublic class LoggingInterceptor
@Aspect annotation
Any bean with a classt t d t p gg g p
{// ...
}
annotated as an aspectwill be automaticallydetected by Spring
Regular bean definitioni ti t b l <bean id="loggingInterceptor"
class="no.uio.inf5750.interceptor.LoggingInterceptor"/>pointing to a bean class
with the @Aspectannotation
![Page 14: Aspect oriented programming_with_spring](https://reader035.fdocuments.net/reader035/viewer/2022081400/555a7845d8b42abb628b45a7/html5/thumbnails/14.jpg)
Declaring a pointcutDeclaring a pointcut
• An expression mapped to a join point (methodinvocation)
AspectJ pointcut expression that determineswhich method executions to intercept
Indicated by the @P i t t t ti @Aspect
Public class LoggingInterceptor{
@Pointcut( "execution( * no.uio.inf5750.dao.*.*(..) )" )private void daoLayer() {}
@Pointcut annotation
private void daoLayer() {}Pointcut signature provided bya regular method definition
![Page 15: Aspect oriented programming_with_spring](https://reader035.fdocuments.net/reader035/viewer/2022081400/555a7845d8b42abb628b45a7/html5/thumbnails/15.jpg)
Pointcut expression patternPointcut expression pattern
• The execution pointcut designator is used most often
Pointcutdesignator.Mandatory.
Can use * tomatch any type.
Mandatory.
Method name.Can use * to
match any type.Mandatory.
Exception type.Optional.
designator( modifiers return-type declaring-type name(params) throws )g ( yp g yp (p ) )
P k d () = no params.Public, private,etc. Optional.
Package andclass name.
Optional.
() no params. (..) = any nr of params.(*,String) = one of any
type, one of String.
![Page 16: Aspect oriented programming_with_spring](https://reader035.fdocuments.net/reader035/viewer/2022081400/555a7845d8b42abb628b45a7/html5/thumbnails/16.jpg)
Pointcut expression examplesPointcut expression examples
execution( public * *(..) )Any public method
execution( public * no.uio.inf5750.dao.*.*(..) )Any public method defined in the dao package
execution( * save*(..) )Any method with a name beginning with savebeginning with save
i ( * i i f5750 d E DAO *(*) )Any method defined by the execution( * no.uio.inf5750.dao.EventDAO.*(*) )Any method defined by theEventDAO interface with one param
![Page 17: Aspect oriented programming_with_spring](https://reader035.fdocuments.net/reader035/viewer/2022081400/555a7845d8b42abb628b45a7/html5/thumbnails/17.jpg)
Declaring adviceDeclaring advice
• Implementation of concern represented as an interceptor• Types
– Before advice– After advice– Around advice
Provides access to the current join point (target object,
d i ti f d i d th d t )– Around advice description of advised method, ect. )
Before advice.Executes before the
matched method
@Aspectpublic class LoggingInterceptor{
@Before( ”no.uio.inf5750.interceptor.LoggingInterceptor.daoLayer()” )matched method.Declared using the
@Before annotation.
public void intercept( JoinPoint joinPoint ){
log.info( ”Executing ” + joinPoint.getSignature().toShortString() );}
![Page 18: Aspect oriented programming_with_spring](https://reader035.fdocuments.net/reader035/viewer/2022081400/555a7845d8b42abb628b45a7/html5/thumbnails/18.jpg)
After returning & throwing adviceAfter returning & throwing advice
After returning advice.Executes after the
matched method has returned normally
@Aspectpublic class LoggingInterceptor{
@AfterReturning( ”no.uio.inf5750.interceptor.LoggingInterceptor.daoLayer()” )bli id i t t( J i P i t j i P i t )returned normally.
Declared using the@AfterReturning
annotation.
public void intercept( JoinPoint joinPoint ){
log.info( ”Executed successfully ” + joinPoint.getSignature().toShortString() );}
After throwing advice.Executes after the
matched method has
@Aspectpublic class LoggingInterceptor{
@AfterThrowing( ”no.uio.inf5750.interceptor.LoggingInterceptor.daoLayer()” )thrown an exception.
Declared using @AfterThrowing.
public void intercept( JoinPoint joinPoint ){
log.info( ”Execution failed ” + joinPoint.getSignature().toShortString() );}
![Page 19: Aspect oriented programming_with_spring](https://reader035.fdocuments.net/reader035/viewer/2022081400/555a7845d8b42abb628b45a7/html5/thumbnails/19.jpg)
Around adviceAround advice
• Can do work both before and after the method executes• Determines when, how and if the method is executed
@Aspectpublic class LoggingInterceptor{
@A d( ” i i f5750 i t t L i I t t d L ()” )Around advice.
The first parametermust be of type
@Around( ”no.uio.inf5750.interceptor.LoggingInterceptor.daoLayer()” )public void intercept( ProceedingJoinPoint joinPoint ){
log.info( ”Executing ” + joinPoint.getSignature().toShortString() );must be of type
ProceedingJoinPoint –calling proceed() causes
the target method toexecute.
try{
joinPoint.proceed();}catch ( Throwable t )execute.
Declared using the@Around annotation.
catch ( Throwable t ){
log.error( t.getMessage() + ”: ” + joinPoint.getSignature().toShortString() );throw t;
}
log.info( ”Successfully executed ” + joinPoint.getSignature().toShortString() );}
![Page 20: Aspect oriented programming_with_spring](https://reader035.fdocuments.net/reader035/viewer/2022081400/555a7845d8b42abb628b45a7/html5/thumbnails/20.jpg)
Accessing argumentsAccessing arguments
• The args binding form makes argument values availableto the advice bodyA t t d ith d i th d• Argument name must correspond with advice methodsignature
@Aspectpublic class LoggingInterceptor
Makes the objectargument available
{@Before( ”no.uio.inf5750.interceptor.LoggingInterceptor.daoLayer() and ” +
”args( object, .. )” )public void intercept( JoinPoint joinPoint, Object object ){
gto the advice body
{log.info( ”Executing ” + joinPoint.getSignature().toShortString() +
” with argument ” + object.toString() );}
Will restrict matchingto methods declaring
at least one parameter
![Page 21: Aspect oriented programming_with_spring](https://reader035.fdocuments.net/reader035/viewer/2022081400/555a7845d8b42abb628b45a7/html5/thumbnails/21.jpg)
Accessing return valuesAccessing return values
• The returning binding form makes the return valueavailable to the advice bodyR t l t d ith d i th d• Return value name must correspond with advice methodsignature
@Aspectpublic class LoggingInterceptor{
Makes the objectreturn value
available to the {@AfterReturning(
pointcut=”no.uio.inf5750.interceptor.LoggingInterceptor.daoLayer() ”,returning=”object” )
public void intercept( JoinPoint joinPoint, Object object )
available to the advice body
{log.info( ”Executed ” + joinPoint.getSignature().toShortString() +
” with return value ” + object.toString() );}
Will restrict matchingto methods returning avalue of specified type
![Page 22: Aspect oriented programming_with_spring](https://reader035.fdocuments.net/reader035/viewer/2022081400/555a7845d8b42abb628b45a7/html5/thumbnails/22.jpg)
Schema based supportSchema-based support
L t d fi t i th t• Lets you define aspects using the aop namespace tags in the Spring configuration file
• Enabled by importing the Spring aop schema
• Pointcut expressions and advice types similar to @AspectJ
• Suitable when:Y bl J– You are unable to use Java 5
– Prefer an XML based format
![Page 23: Aspect oriented programming_with_spring](https://reader035.fdocuments.net/reader035/viewer/2022081400/555a7845d8b42abb628b45a7/html5/thumbnails/23.jpg)
Declaring an aspectDeclaring an aspect
• An aspect is a regular Java object defined as a bean in the Spring context
All configuration insidean <aop:config> element
Aspect declared using
<aop:config>
<aop:aspect id=”logging” ref=”loggingInterceptor”>p gthe <aop:aspect>
element. Backing bean is referenced
with the ref attribute.
</aop:aspect>
</aop:config>
<bean id="loggingInterceptor"class="no.uio.inf5750.interceptor.LoggingInterceptor"/>
Regular bean definitionRegular bean definition
![Page 24: Aspect oriented programming_with_spring](https://reader035.fdocuments.net/reader035/viewer/2022081400/555a7845d8b42abb628b45a7/html5/thumbnails/24.jpg)
Declaring a pointcutDeclaring a pointcut
• Pointcut expressions are similar to @AspectJ• A pointcut can be shared across advice
Pointcut declared inside<aop:config> element
using the <aop:pointcut> element
<aop:config>
<aop pointc t id ”daoLa er”<aop:pointcut id=”daoLayer” expression="execution( * no.uio.inf5750.dao.*.*(..) )”/>
</aop:config>Can also be defined
inside aspects
![Page 25: Aspect oriented programming_with_spring](https://reader035.fdocuments.net/reader035/viewer/2022081400/555a7845d8b42abb628b45a7/html5/thumbnails/25.jpg)
Declaring adviceDeclaring advice
Before advice.
Declared inside anaspect
<aop:aspect id=”logging” ref=”loggingInterceptor”>
<aop:before pointcut-ref=”daoLayer” method=”intercept”/>
</aop:aspect>aspect. </aop:aspect>
Refers to pointcut Refers to advising methodRefers to pointcut Refers to advising method
public class LoggingInterceptor{
public void intercept( JoinPoint joinPoint ){
Advice is a regular Java class
// Do some useful intercepting work}
}
![Page 26: Aspect oriented programming_with_spring](https://reader035.fdocuments.net/reader035/viewer/2022081400/555a7845d8b42abb628b45a7/html5/thumbnails/26.jpg)
Declaring adviceDeclaring advice
After returning advice
<aop:aspect id=”logging” ref=”loggingInterceptor”>
<aop:after-returning pointcut-ref=”daoLayer” method=”intercept”/>
</aop:aspect>
After throwing advice
<aop:aspect id=”logging” ref=”loggingInterceptor”>
<aop:after-throwing pointcut-ref=”daoLayer” method=”intercept”/>
</aop:aspect>
Around advice
<aop:aspect id=”logging” ref=”loggingInterceptor”>
<aop:around pointcut-ref=”daoLayer” method=”intercept”/>
</aop:aspect>
![Page 27: Aspect oriented programming_with_spring](https://reader035.fdocuments.net/reader035/viewer/2022081400/555a7845d8b42abb628b45a7/html5/thumbnails/27.jpg)
AOP Transaction ManagementAOP - Transaction Managementbli i f T i M
TransactionManagerinterface
public interface TransactionManager{
public void enter();public void abort();public void leave();p ();
@Aspectpublic interface TransactionInterceptor{
Transaction managementimplemented with {
@Around( ”execution( public no.uio.inf5750.dao.*.*(..) )” ) // In-line pointcutpublic void intercept( ProceedingJoinPoint joinPoint ){
transactionManager.enter();
implemented witharound advice
Enters transaction g ();
try{
joinPoint.proceed();}
Enters transactionbefore method invocation
}catch ( Throwable t ){
transactionManager.abort();throw t;
}
Aborts and rolls back transaction if method fails
}
transactionManager.leave();Leaves transaction if
method completes norm.
![Page 28: Aspect oriented programming_with_spring](https://reader035.fdocuments.net/reader035/viewer/2022081400/555a7845d8b42abb628b45a7/html5/thumbnails/28.jpg)
@AspectJ or Schema based?@AspectJ or Schema-based?
• Advantages of schema style– Can be used with any JDK level
Clearer which aspects are present in the system– Clearer which aspects are present in the system
• Advantages of @AspectJ style• Advantages of @AspectJ style– One single unit where information is encapsulated for an aspect– Possible to combine named pointcutsPossible to combine named pointcuts– Can be understood by AspectJ – easy to migrate later
![Page 29: Aspect oriented programming_with_spring](https://reader035.fdocuments.net/reader035/viewer/2022081400/555a7845d8b42abb628b45a7/html5/thumbnails/29.jpg)
SummarySummary
• Key components in AOP are aspect, pointcut, join point, and advice
• AOP lets you encapsulate functionality that affectsmultiple classes in an interceptormultiple classes in an interceptor
• Advantages of AOP:• Advantages of AOP:– Promotes separation of concern– Promotes code reuse and modularizationPromotes code reuse and modularization– Promotes loosely coupled design
![Page 30: Aspect oriented programming_with_spring](https://reader035.fdocuments.net/reader035/viewer/2022081400/555a7845d8b42abb628b45a7/html5/thumbnails/30.jpg)
ReferencesReferences
• The Spring reference documentation - Chapter 6– www.springframework.org
• AOP example code– www ifi uio no/INF5750/h07/undervisningsplan xml– www.ifi.uio.no/INF5750/h07/undervisningsplan.xml