Spring framework aop

Spring Framework
AOP
2st WEEK
30 Jun
GEEKY ACADEMY 2013

2 | GEEK ACADEMY 2013
INSTRUCTOR TEAM
SALAHPIYA
Salah (Dean) Chalermthai
Siam Chamnan Kit
SChalermthai@sprint3r.com
Piya (Tae) Lumyong
-
piya.tae@gmail.com

Topic
• Intro to AOP
• Basic AOP Concepts
• Getting Started with Spring AOP

Introduction to AOP
GEEK ACADEMY 2013

Intro to AOP
• Why worrying about Crosscutting Concerns?
• What AOP Does?
• Crosscutting Concerns
• Example

Why worrying about Crosscutting Concerns?
public void withdraw(long accId, int amount) {
Account account = (Account)session.get(Account.class, accId);
double balance = account.getBalance();
balance = balance - amount;
account.setBalance(balance);
session.save(balance);
}
Business

if (hasPermission(accId)) {
} else {
throw new SecurityException("Access Denied");
}
}
Business
Permission

bankLogger.info(accId + " withdrow amount " + amount);
} else {
}
}
Business
Permission
Logger

bankLogger.info(accId + " withdrow amount " + amount);
Transaction tx = null;
try {
Transaction tx = session.beginTransaction();
tx.commit();
} catch(RuntimeException ex) {
if (tx!=null) tx.rollback;
}
} else {
}
}
Business
Permission
Logger
Transaction

Business
Permission
Logger
Transaction
Service A
Service B
Service C

• Too many relationship to the crosscutting objects
• Code is still required in all methods
• Cannot all be changed at one

What AOP Does?
• AOP will separate the Crosscutting concerns from the
System

Crosscutting Concerns
public void withdraw(int amount) {
}
public void deposit(int amount) {
balance = balance + amount;
}
Logger
bankLogger.info("Withdraw " + amount); bankLogger.info("Withdraw " + amount);
Transaction
tx.commit(); tx.commit();
tx.begin(); tx.begin();
Ref AOP Spring

Cross-Cutting Concerns Examples
• Logging and Tracing
• Transaction Management
• Security
• Caching
• Error Handling
• Performance Monitoring
• Custom Business Rules

Basic AOP Concepts
GEEK ACADEMY 2013

Basic AOP Concepts
• What is AOP?
• AOP Terminology
• Advice
• How Spring AOP Works
• AOP and OOP
• Leading AOP Technologies

What is AOP?
• is a programming paradigm
• extends OOP
• enables modularization of crosscutting concerns
• is second heart of
Spring Framework

AOP Terminology

AOP Terminology
• Joinpoint – Defines A Point During the Execution of a
program. We can insert Additional logics at Joinpoints
• Advice – Action taken(Functionality) at a Joinpoint.
• Pointcut – Combination of Joinpoints where the Advice
need to be Applied.

AOP Terminology
• Aspect – a modularization of a Crosscutting concern.
• Target object - object being advised by one or more aspects.
• AOP proxy – Will manage the way of Applying Aspects at
particular Pointcuts.
PointCut
Advice
PointCut
Advice
PointCut
Advice
Aspect
Target Object
Proxy
Call

AOP Weaving
• Process of applying aspects to a target object
• Will create a proxied object

How AOP Works
• Write your mainline application logic (Solve core problem)
• Write aspects to implement cross-cutting concerns (Write aspects)
• Bind it all together (Weave at runtime)

AOP and OOP
• Aspect – code unit that encapsulates
pointcuts, advice, and attributes
• Pointcut – define the set of entry points
(triggers) in which advice is executed
• Advice – implementation of cross
cutting concern
• Weaver – construct code (source or
object) with advice
• Class – code unit that encapsulates
methods and attributes
• Method signature – define the entry
points for the execution of method bodies
• Method bodies – implementation of the
business logic concerns
• Compiler – convert source code to object
code
AOP OOP

Leading AOP Technologies
• AspectJ
– 1995, original AOP technology
– Offers a full Aspect Oriented Programming language
– Modifies byte code to add aspects into your application!
• Spring AOP
– Uses dynamic proxies to add aspects into your application
– Only spring beans can be advised
– Uses some of AspectJ expression syntax

Getting Started with
Spring AOP
GEEK ACADEMY 2013

Getting Started with Spring AOP
• Spring AOP
• Aspect
• Pointcut
• Advice
• Bean in Spring container
• How it really works
• Additional
• Spring AOP vs AspectJ
• @AspectJ vs XML

Spring AOP
• Implemented in pure java
• No need for a special compilation process
• Supports only method execution join points
• Only runtime weaving is available
• AOP proxy
– JDK dynamic proxy
– CGLIB proxy
• Configuration
– @AspectJ annotation-style
– Spring XML configuration-style

@Aspect
@Aspect
public class LoggingAspect {
...
}
<aop:aspectj-autoproxy />
<bean class="mypackage.LoggingAspect" />

Pointcut

Pointcut
• @Pointcut
• Pointcut expression
• Pointcut designators
• Example

@Pointcut
@Aspect
@Pointcut("execution(* mypackage.service..*.*(..))")
public void ifService() {}
@Pointcut("execution(* mypackage.repository..*.*(..))")
public void ifRepository() {}
...
}

Pointcut expression
• PCD - Pointcut designators.
• method scope
– Advice will be applied to all the methods having this scope.
For e.g., public, private, etc. Spring AOP only supports
advising public methods.
• return type
– Advice will be applied to all the methods having this return
type.
PCD(<method scope> <return type> <declaring type>.<name(param)> <throw>)

Pointcut expression(2)
• declaring type
– Advice will be applied to all the methods of this type. If the class
and advice are in the same package then package name is not
required
• name(param)
– Filter the method names and the argument types.
Two dots(..) means any number(0-more) and type of parameters.
• throw
PCD(<method scope> <return type> <declaring type>.<name(param)> <throw>)

Pointcut designators
• Code based
– execution (Method Patterns)
• the primary pointcut designator you will use when working with Spring AOP
– within (Type Patterns)
• within certain types (simply the execution of a method declared within a
matching type when using Spring AOP)
– target
• where the target object (application object being proxied) is an instance of
the given type

Pointcut designators(2)
• Code based(2)
– this
• where the bean reference (Spring AOP proxy) is an instance of the given
type
– args
• where the arguments are instances of the given types
– bean (Bean Name Patterns)
• to a particular named Spring bean, or to a set of named Spring beans (when
using wildcards)

• Annotation based
– @annotation
• where the subject of the join point (method being executed in Spring AOP)
has the given annotation
– @within
• within types that have the given annotation (the execution of methods
declared in types with the given annotation when using Spring AOP)

• Annotation based(2)
– @target
• where the class of the executing object has an annotation of the given type
– @args
• where the runtime type of the actual arguments passed have annotations of
the given type(s)

Pointcut example
• the execution of any public method:
execution(public * *(..))
• the execution of any method with a name beginning with “set”:
execution(* set*(..))
• the execution of any method defined by the MyService interface
execution(* com.xyz.service.MyService.*(..))
• the execution of any method defined in the service package:
execution(* com.xyz.service.*.*(..))
• the execution of any method defined in the service package or a
sub-package:
execution(* com.xyz.service..*.*(..))

Pointcut example(2)
• any join point (method execution only in Spring AOP) WITHIN the
service package:
within(com.xyz.service.*)
• any join point (method execution only in Spring AOP) within the
service package or a sub-package:
within(com.xyz.service..*)
• any join point (method execution only in Spring AOP) where the
proxy implements the AccountService interface:
this(com.xyz.service.AccountService)

Pointcut example(3)
• Other example
– Pointcut example - Spring Framework Reference

Advice
• Advice types
• @Before
• @After
• @AfterReturning
• @AfterThrowing
• @Around

Advice
• Action teken at particular Joinpoint is called as an Advice
• Defines What needs to be Applied and When
– What – Functionality
– When – Advice Type

Advice types
• Before
• After
• After Returning
• After Throwing
• Around
Method
Return Throw
Success call
Call

@Before
@Aspect
@Pointcut("execution(* *(..))")
@Before("ifService()")
public void logBefore(JoinPoint joinPoint) {
...
}
...
}

@After
@Aspect
@After("ifService()")
public void logAfter(JoinPoint joinPoint) {
...
}
...
}

@AfterReturning
@Aspect
@AfterReturning(pointcut = "ifService()", returning = "result")
public void logAfterReturning(JoinPoint joinPoint, Object result) {
...
}
...
}

@AfterThrowing
@Aspect
@AfterThrowing(pointcut = "ifService()", throwing = "error")
public void logAfterThrowing(JoinPoint joinPoint, Throwable error) {
...
}
...
}

@Around
@Aspect
@Around("ifService()")
public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
...
Object result = joinPoint.proceed();
...
return result;
}
...
}

Security
Bean in Spring container
Logging
Caching
Target
Object

How it really works (TX example)

LAB1 Basic Spring AOP

LAB1 Basic Spring AOP
Target
Object
Logging

Links
• SpringSource
• Spring Reference 3.2
• Thank for
– Dmitry Noskov
– chamilavt
– Java Brains

THANK YOU FOR
YOUR TIME
GEEK ACADEMY 2013

Spring framework aop

Recommended

More Related Content

What's hot (20)

Similar to Spring framework aop (20)

Recently uploaded (20)

Spring framework aop