AOP

Aspect Oriented
Programming
Aspect-oriented programming with Spring framework

Aspect Oriented Programming
 Gregor Kiczales
Gregor Kiczales is a professor
of computer science at the
University of British Columbia
in Canada.
His best-known work is on
aspect-oriented programming
and the AspectJ extension for
Java at Xerox PARC.
Wikipedia
Born: 1961
Alma mater: Massachusetts
Institute of Technology
Books: The Art of the
Metaobject Protocol

 US patented

as·pect
/ˈaspekt/
noun
1. a particular part or feature of something.
feature, facet, side, characteristic, particular, detail; angle, slant
a specific way in which something can be considered.
a particular appearance or quality.
appearance, look, air, cast, mien, demeanor, expression
2. the positioning of a building or thing in a specified direction

 Aspect Oriented Programming
In computing, aspect-oriented programming (AOP) is a
patented programming paradigm that aims to increase
modularity by allowing the separation of cross-cutting
concerns.
Wikipedia
Aspect-Oriented Programming (AOP) complements Object-Oriented
Programming (OOP) by providing another way of thinking about
program structure. The key unit of modularity in OOP is the class,
whereas in AOP the unit of modularity is the aspect. Aspects enable
the modularization of concerns such as transaction management that
cut across multiple types and objects. (Such concerns are often termed
crosscutting concerns in AOP literature.)
Spring framework reference

 AOP implemented languages
Java
AspectJ
JavaScript
Logtalk
Lua
make
Matlab
ML
Perl
PHP
Prolog
Python
Racket
Ruby
Squeak Smalltalk
UML 2.0
XM
.NET Framework languages
(C# / VB.NET)
ActionScript
Ada
AutoHotkey
C / C++
COBOL
The Cocoa Objective-C
frameworks
ColdFusion
Common Lisp
Delphi
Delphi Prism
e (IEEE 1647)
Emacs Lisp
Groovy
Haskell

 AOP Terminologies
 Aspect: a modularization of a concern that cuts across multiple classes. Transaction management is a good example of a crosscutting concern
in enterprise Java applications. In Spring AOP, aspects are implemented using regular classes (the schema-based approach) or regular classes
annotated with the @Aspectannotation (the @AspectJ style).
 Join point: a point during the execution of a program, such as the execution of a method or the handling of an exception. In Spring AOP, a
join point alwaysrepresents a method execution.
 Advice: action taken by an aspect at a particular join point. Different types of advice include "around," "before" and "after" advice. (Advice
types are discussed below.) Many AOP frameworks, including Spring, model an advice as an interceptor, maintaining a chain of
interceptors around the join point.
 Pointcut: a predicate that matches join points. Advice is associated with a pointcut expression and runs at any join point matched by the
pointcut (for example, the execution of a method with a certain name). The concept of join points as matched by pointcut expressions is
central to AOP, and Spring uses the AspectJ pointcut expression language by default.
 Introduction: declaring additional methods or fields on behalf of a type. Spring AOP allows you to introduce new interfaces (and a
corresponding implementation) to any advised object. For example, you could use an introduction to make a bean implement
an IsModified interface, to simplify caching. (An introduction is known as an inter-type declaration in the AspectJ community.)
 Target object: object being advised by one or more aspects. Also referred to as the advised object. Since Spring AOP is implemented using
runtime proxies, this object will always be a proxied object.
 AOP proxy: an object created by the AOP framework in order to implement the aspect contracts (advise method executions and so on). In the
Spring Framework, an AOP proxy will be a JDK dynamic proxy or a CGLIB proxy.
 Weaving: linking aspects with other application types or objects to create an advised object. This can be done at compile time (using the
AspectJ compiler, for example), load time, or at runtime. Spring AOP, like other pure Java AOP frameworks, performs weaving at runtime

 Types of advice
 Before advice: Advice that executes before a join point, but which does not have the ability to
prevent execution flow proceeding to the join point (unless it throws an exception).
 After returning advice: Advice to be executed after a join point completes normally: for example, if
a method returns without throwing an exception.
 After throwing advice: Advice to be executed if a method exits by throwing an exception.
 After (finally) advice: Advice to be executed regardless of the means by which a join point exits
(normal or exceptional return).
 Around advice: Advice that surrounds a join point such as a method invocation. This is the most
powerful kind of advice. Around advice can perform custom behavior before and after the
method invocation. It is also responsible for choosing whether to proceed to the join point or to
shortcut the advised method execution by returning its own return value or throwing an exception.

 AOP terminology
Advice injected code
Join Point a point of execution
Pointcut
point of injection
(set of Join Point)
Aspect Advice + Pointcut
Weaving process of injection

 AOP terminology

 Proxy
Structure

 Dynamic Proxy

public interface Foo {
Object bar(Object obj) throws BazException;
}
public class FooImpl implements Foo {
Object bar(Object obj) throws BazException {
// ...
}
}
public class DebugProxy implements java.lang.reflect.InvocationHandler {
private Object obj;
public static Object newInstance(Object obj) {
return java.lang.reflect.Proxy.newProxyInstance(
obj.getClass().getClassLoader(),
obj.getClass().getInterfaces(),
new DebugProxy(obj));
}
private DebugProxy(Object obj) {
this.obj = obj;
}
public Object invoke(Object proxy, Method m, Object[] args) throws Throwable
{
Object result;
try {
System.out.println("before method " + m.getName());
result = m.invoke(obj, args);
} catch (InvocationTargetException e) {
throw e.getTargetException();
} catch (Exception e) {
throw new RuntimeException("unexpected invocation exception: " +
e.getMessage());
} finally {
System.out.println("after method " + m.getName());
}
return result;
}
} https://docs.oracle.com/javase/8/docs/technotes/guides/reflection/proxy.html

 Code Example
http://www.mkyong.com/spring/spring-aop-examples-advice/
Mobile API Cache

 AspectJ
AspectJ is an aspect-oriented programming (AOP) extension created at
PARC for the Java programming language.
It is available in Eclipse Foundation open-source project

 Reference
https://en.wikipedia.org/wiki/Aspect-oriented_programming
http://docs.spring.io/spring/docs/current/spring-framework-
reference/html/aop.html
https://www.opencredo.com/2015/07/14/dynamic-proxies-java-part-
2/
https://en.wikipedia.org/wiki/AspectJ
https://en.wikipedia.org/wiki/Spring_Framework#Aspect-
oriented_programming_framework
https://en.wikipedia.org/wiki/Aspect-oriented_software_development
http://www.eclipse.org/aspectj/
https://www.google.com/patents/US6467086
http://java2novice.com/spring/aop-and-aspectj-introduction/

AOP

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Destacado

Destacado (17)

Similar a AOP

Similar a AOP (20)

Más de Joshua Yoon

Más de Joshua Yoon (6)

Último

Último (20)

AOP