• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Aspect Oriented Programming
 

Aspect Oriented Programming

on

  • 6,651 views

 

Statistics

Views

Total Views
6,651
Views on SlideShare
6,625
Embed Views
26

Actions

Likes
8
Downloads
0
Comments
0

3 Embeds 26

http://www.slideshare.net 19
http://www.linkedin.com 5
https://www.linkedin.com 2

Accessibility

Categories

Upload Details

Uploaded via as OpenOffice

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Aspect Oriented Programming Aspect Oriented Programming Presentation Transcript

    • Aspect-Oriented Programming
      • AOP
      • Programmazione Orientata agli Aspetti
      • Un sistema software è la realizzazione di una serie di requisiti
      • In fase di disegno di un sistema i requisiti vengono classificati e raggruppati allo scopo di identificare i moduli implementativi
      • Separare le realizzazioni dei requisiti in moduli differenti è una fase fondamentale per la realizzazione del sistema
      • Si assegnano così le responsabilità ad ogni modulo che risulta coeso e non accoppiato
      • Le metodologie di programmazione in vario modo supportano la Separation Of Concerns
      Separation of concerns Aspect-Oriented Programming
      • L'ingegneria del software si è occupata di trovare un rimedio al problema della Separation Of Concern introducendo i concetti di modularizzazione e sviluppando metodologie e linguaggi che supportassero tali concetti.
      • In questo senso abbiamo assistito ad un'evoluzione nelle metodologie e negli strumenti di supporto a queste:
      • I linguaggi procedurali hanno introdotto l’astrazione funzionale
      • L’OOP ha introdotto il concetto di astrazione di 'oggetto' e quindi il costrutto di classe
      • L’AOP introduce il concetto di astrazione di 'concern' e quindi il costrutto di aspetto
      Aspect-Oriented Programming Separation of concerns
      • In un sistema bancario i concerns sono rispettivamente:
      • la gestione dei clienti
      • il calcolo degli interessi
      • la gestione del bancomat
      • la gestione della persistenza
      • la gestione delle autorizzazioni
      • la gestione della sicurezza
      • il logging
      • ...
      Esempio di concerns di un sistema Aspect-Oriented Programming
      • Un concern è un requisito che deve essere soddisfatto al fine di realizzare gli obiettivi dell'intero sistema
      • di conseguenza:
      • Un sistema software è la realizzazione di una serie di concerns
      Definizione di Concern Aspect-Oriented Programming
      • In un sistema bancario i concerns sono rispettivamente:
      • la gestione dei clienti
      • il calcolo degli interessi
      • la gestione dell'ATM (bancomat)
      • la gestione della persistenza
      • la gestione delle autorizzazioni
      • la gestione della sicurezza
      • il logging
      • ...
      Esempio di concerns di un sistema Aspect-Oriented Programming Core concerns Crosscutting concerns
      • Sono concerns la cui implemetazione è 'trasversale' a molti moduli del sistema
      Aspect-Oriented Programming Crosscutting Concerns
      • XML parsing in org.apache.tomcat
        • Ottima modularizzazione
      Aspect-Oriented Programming Case study Apache
      • URL Pattern matching in org.apache.tomcat
        • Buona modularizzazione
      Aspect-Oriented Programming Case study Apache
      • Logging in org.apache.tomcat
        • Pessima modularizzazione
      Aspect-Oriented Programming Case study Apache
      • Code tangling:
        • si ha quando un modulo deve gestire più concerns contemporaneamente, business logic, performance, logging, security, ...
        • e quando un modulo presenta al suo interno elementi implementativi di altri concerns
      Aspect-Oriented Programming Crosscutting Concerns - conseguenze
      • Code scattering:
        • si ha quando una funzionalità è implementata in più di un modulo (il requisito è disperso)
        • è di due tipologie:
          • Blocchi di codice duplicato: stesso codice in moduli differenti
          • Blocchi di codice complementare: altri moduli implementano parti complementari del concern
      Aspect-Oriented Programming Crosscutting Concerns - conseguenze
      • Quindi il sistema presenta i seguenti difetti:
        • Codice ridondante
        • La sua struttura tende a non essere esplicita
        • Presenta difficoltà nell'implementazione di ulteriori requisiti
      • L'OOP in questo caso non è in grado di fornire un adeguato supporto
      Aspect-Oriented Programming Crosscutting Concerns - conseguenze
      • L'Aspect Oriented Programming complementa l'OOP
      • Offre gli strumenti e i costrutti per la modularizzazione dei crosscutting concerns
      • Abilita l'applicazione dei crosscutting concerns in modo dichiarativo
      • Favorisce il disaccoppiamento fra i moduli
      • Consente, attraverso l'uso degli aspetti, la rimozione delle dipendenze di un crosscutting concerns nei moduli interessati
      Aspect-Oriented Programming Overview
      • Aspect : funzionalità crosscutting
      • Joinpoint : punto di applicazione dell'aspetto (when)
      • Advice : l'implementazione del crosscutting concern (what)
      • Pointcut : espressione per la selezione dei joinpoint (where)
      • Target : il modulo (oggetto) dove verrà applicato l'aspetto
      Aspect-Oriented Programming Terminologia
      • Fra le varie implementazioni open source si distinguono per qualità e diffusione:
      • AspectJ
        • Reference implementation per l'AOP
      • Spring AOP
        • Basandosi sui pricipi fondamentali di Spring come la DI offre strumenti di supporto dichiarativi per l'AOP basati su XML e annotazioni Java
      Aspect-Oriented Programming AOP's Java framework
        • AspectJ
      Aspect-Oriented Programming AspectJ
      • E' un'estensione del linguaggio Java:
        • Ogni programma aspectj è un programma java
        • Sfrutta tutte le potenzialità del linguaggio
        • Bassa curva di apprendimento
      • Come ogni linguaggio è costituito da:
        • Una definizione: aggiunge i costrutti per il weaving dei crosscutting concern
        • Una implementazione: compilatore, debugger e l'integrazione con i più diffusi ambienti di sviluppo
      Aspect-Oriented Programming AspectJ
      • Rappresenta un punto di esecuzione di un programma:
        • Invocazione ed esecuzione di un metodo
        • Invocazione ed esecuzione del costruttore
        • Accesso ai campi
        • Inizializzazione di classe
        • Lancio di una eccezione
      • quindi dove applicare un crosscutting concern
        • dove viene effettivamente applicato un aspetto
      Aspect-Oriented Programming AspectJ - Joinpoint
      • E' il costrutto che consente di esprimere i criteri per la selezione dei joinpoints
      • E' possibile collezionare il contesto di esecuzione nei joinpoints selezionati dal pointcut
      • Esempio:
      Aspect-Oriented Programming AspectJ - Pointcut public pointcut print() : call ( public void Message.print*(..));
      • Specifica il codice che deve essere eseguito ad un pointcut
      • AspectJ consente tre modalità di applicazione di un advice:
        • before: prima joinpoint
        • After: dopo
        • Around: intorno al joinpoint
      • Esempio:
      Aspect-Oriented Programming AspectJ - Advice void around () : print() { System.out.println( "Buongiorno!" ); proceed (); System.out.println( "Arrivederci!" ); return ; }
      • Aspects è l'unità di modularizzazione del concern, ed è come una classe java
      • Un aspetto contiene i pointcuts e gli advice
      • Esempio:
      Aspect-Oriented Programming AspectJ - Aspect public aspect ServiceAspect { public pointcut print() : call ( public void Message.print*(..)); void around () : print() { System.out.println( "Buongiorno!" ); proceed (); System.out.println( "Arrivederci!" ); return ; } }
        • Spring AOP
      Aspect-Oriented Programming Spring AOP
    • Aspect-Oriented Programming Pattern GoF DECORATOR - Abstract
      • Aggiunge comportamenti addizionali ad un oggetto dinamicamente.
      • Può essere applicato:
      • per “decorare” con azioni un oggetto a run-time senza impatti per l'oggetto decorato
      • per suddividere le responsabilità e aumentare il disaccoppiamento
      • per privilegiare la composizione (HAS-A) all'estensione (IS-A)
      • per aprire alle estensioni ma chiudere alle modifiche le classi ( open-closed principle )
      • Ritroviamo esempi pratici di DECORATOR all'interno della JSE nel package java.io (classi input/output streams) e in ambito JEE nei Filter .
    • Aspect-Oriented Programming Pattern GoF DECORATOR - Class diagram
    • Aspect-Oriented Programming Pattern GoF PROXY - Abstract
      • Fornisce un surrogato di un oggetto target per controllarne l'accesso.
      • Può essere applicato:
      • per fornire una rappresentazione di un oggetto distribuito sulla rete (REMOTE PROXY )
      • per fornire uno strumento che faciliti il lazy-loading di risorse all'interno della classe ( VIRTUAL PROXY )
      • per controllare l'accesso all'oggetto target (PROTECTION PROXY)
      • per applicare comportamenti addizionali quando l'oggetto target è invocato ( SMART REFERENCE )
      • Si distingue dal DECORATOR (o WRAPPER) perchè hai il controllo completo dell'accesso. Ritroviamo un esempio pratico di applicazione del pattern PROXY all'interno della tecnologia RMI (oggetto stub ).
    • Aspect-Oriented Programming Pattern GoF PROXY - Class diagram
    • Aspect-Oriented Programming DYNAMIC PROXY - Abstract
      • Presenti dalla versione 1.3 della JSE, una Dynamic Proxy Class è una classe che implementa a run-time, piuttosto che a design-time, una o più interfacce.
      • target interface
      • target class
      • invocation handler (implementa java.lang.reflect.InvocationHandler )
      • dynamic proxy class (generata a run-time dalla JVM)
    • Aspect-Oriented Programming DYNAMIC PROXY - Class diagram
    • Aspect-Oriented Programming DYNAMIC PROXY - Sequence diagram
    • Aspect-Oriented Programming DYNAMIC PROXY - Invocation handler POJO impl interface dynamic proxy factory invocation handler
    • Aspect-Oriented Programming Spring AOP module
    • Aspect-Oriented Programming SPRING AOP Support
      • Spring fornisce le seguenti modalità di supporto alla programmazione orientata agli aspetti:
      • Proxy Factory Bean
      • @AspectJ annotation-driven
      • Pure-POJO
    • Aspect-Oriented Programming PROXY FACTORY BEAN - Proxy mode Target Bean Target Interface Proxy Factory Interceptor List Pointcut Advice
    • Aspect-Oriented Programming PROXY FACTORY BEAN - Decorator mode
        • Permette di evitare la dependency injection automatizzando la creazione dei proxy che soddisfano il pointcut definito
      Aspect-Oriented Programming PROXY FACTORY BEAN – Autoproxy facility BeanPostProcessor Pointcut Advice
    • Aspect-Oriented Programming SPRING AOP - Advice
      • Before org.springframework.aop.MethodBeforeAdvice
      • After-returning org.springframework.aop.AfterReturningAdvice
      • After-throwing org.springframework.aop.ThrowsAdvice
      • Around org.aopalliance.intercept.MethodInterceptor
      • Introduction org.springframework.aop.IntroductionInterceptor
    • Aspect-Oriented Programming Around Advice
    • Aspect-Oriented Programming Around Advice - Code
        • AspectJ mette a disposizione la possibilità di configurare POJO come aspetti mediante annotazioni .
        • Per facilitare l'attivazione di un bean AspectJ e trattarlo come un aspetto Spring mette a disposizione un autoproxy factory
        • <aop:aspectj-autoproxy>
      Aspect-Oriented Programming @AspectJ annotation crea un autoproxy factory di tipo AnnotationAwareAspectJ AutoProxyCreator @AspectJ annotations
        • Permette di applicare aspetti ad una classe POJO in una modalità meno invasiva rispetto all'uso della ProxyFactoryBean
      Aspect-Oriented Programming Pure POJO aspect Before Advice XML Tag
    • <aop:config> <aop:aspect> <aop:advisor> <aop:pointcut> <aop:before> <aop:around> <aop:after> <aop:after-returning> <aop:after-throwing>
        • Tag XML per la dichiarazione di
        • POJO-based aspects
      Aspect-Oriented Programming Pure POJO XML elements
      • Servizio per recupero account utente.
      • Comportamenti cross-cutting individuati:
      • tracing Before
      • hit counter Before
      • caching Around
      • error handler After-throwing
      Aspect-Oriented Programming Case study overview
    • ...let's coding... Aspect-Oriented Programming Case study live session
    • References
      • http://aopalliance.sourceforge.net/
      • http://www.springframework.org/
      • http://www.eclipse.org/aspectj/
      • Spring in Action – Craig Walls with Ryan Breidenbach – Manning
      • AspectJ in Action - Ramnivas Laddad - Manning
      • Expert One-on-One J2EE Design and Development - Rod Johnson – Wrox
      • Expert One-on-One J2EE Development without EJB - Rod Johnson, Juergen Hoeller - Wrox
      Aspect-Oriented Programming
      • Grazie per la cortese attenzione e...
      ...happy coding applying aspects!!! Aspect-Oriented Programming Conclusioni