Σημειώσεις:Τεχνολογίες Υλοποίησης:Spring

Από DistrSys

Πίνακας περιεχομένων 1 Spring 2 Τι είναι η Spring 3 Τα modules της Spring 4 ́Ενα παράδειγμα 5 Κατανοώντας το dependency injection 6 Aspect-Oriented Programming

Spring

Τα τελευταία χρόνια ο κόσμος της Java υπήρξε μάρτυρας μίας δραματικής αλλαγής στον τρόπο ανάπτυξης μεγάλων Java εφαρμογών. Η χρήση των λεγόμενων ‘βαρέων’ αρχιτεκτονικών (Heavyweight Architectures), όπως είναι τα Enterprise Java Beans (EJB), έχει περιοριστεί και τη θέση τους έχουν πάρει πιο ‘ελαφριά’ περιβάλλοντα εργασίας (frameworks). Πολύπλοκες και εξαρτώμενες από την κάθε τεχνολογία υπηρεσίες, όπως το object/relational mapping (ORM) και τα συστήμα τα διαχείρισης συναλλαγών (transaction management systems), έχουν αντικατασταθεί από πιο απλές εναλλακτικές. ́Ενα τέτοιο, πολλά υποσχόμενο και δημοφιλές περιβάλλον εργασίας είναι η Spring. Η Spring αποτελεί ένα υψηλής ποιότητας και ευχρηστίας project το οποίο ικανοποιεί τις ανάγκες και τις απαιτήσεις των πραγματικών Java εφαρμογών.

Τι είναι η Spring

Η Spring είναι ένα ελεύθερο (open source) περιβάλλον εργασίας για εφαρμογές Java που δημιουργήθηκε από τον Rob Johnson και περιγράφηκε στο βιβλίο του ‘‘Expert One-on-One: J2EE Design and Development’’. Αναπτύχθηκε κατά κύριο λόγο, για να αντιμετωπίσει την πολυπλοκότητα ανάπτυξης enterprise εφαρμογών.Η Spring κάνει εφικτή την χρήση απλών JavaBeans για την επίτευξη πραγμάτων που προηγουμένως μπορούσαν να γίνουν μόνο μέσω EJBs. Παρ ́ όλα αυτά, η Spring δεν είναι μόνο χρήσιμη για την ανάπτυξη server-side εφαρμογών. Η χρήση της μπορεί να βοηθήσει στην απλοποίηση του κώδικα, τον ευκολότερο και πιο αποτελεσματικό έλεγχο και τη χαλαρή διασύνδεση (loose coupling) κάθε Java εφαρμογής.

Η Spring κάνει πολλά πράγματα, αλλά, αν την αναλύσει κάποιος στα βασικά της κομμάτια, θα δει ότι είναι ένας ελαφρύς (lightweight) aspect-oriented container ο οποίος εφαρμόζει dependency injection, ενώ παράλληλα αποτελεί και περιβάλλον εργασίας (framework). Για να γίνουν τα πράγματα πιο κατανοητά θα γίνεται ανάλυση της περιγραφής αυτής :

• Lightweight (Ελαφρύς) — Με τον όρο αυτό αναφερόμαστε τόσο στο μέγεθος όσο και στον επιπλέον φόρτο (overhead). Η διανομή του Spring Framework μπορεί να συμπεριληφθεί σε ένα απλό jar αρχείο μεγέθους 2,5 MB, ενώ ο επιπρόσθετος φόρτος εργασίας που απαιτείται είναι αμελητέος. Ο προγραμματιστής χρειάζεται να κάνει ελάχιστες, αν όχι καθόλου, αλλαγές στον κώδικα της εφαρμογής που αναπτύσσει έτσι, ώστε να επωφεληθεί από τον πυρήνα της, ενώ μπορεί οποιαδήποτε στιγμή να σταματήσει να τη χρησιμοποιεί. Βέβαια αυτού του είδους η ευχέρεια παρέχεται μόνο στον πυρήνα της Spring. Πολλά επιπλέον μέρη της, όπως είναι η πρόσβαση δεδομένων,απαιτούν πολύ στενότερη ‘διασύνδεση’ (coupling) από ότι το Spring framework. Παρ ́ όλα αυτά, το κέρδος στις περισσότερες από αυτές τις περιπτώσεις είναι πολύ σημαντικό.
• Dependency Injection — Η Spring προάγει τη χαλαρή διασύνδεση χρησιμοποιώντας μία τεχνική που είναι γνωστή ως dependency injection (DI).'Οταν εφαρμόζεται η DI, τα αντικείμενα λαμβάνουν παθητικά τις εξαρτήσεις τους (dependencies) αντί να τις δημιουργούν ή να τις αναζητούν μόνα τους.Είναι κάτι σαν ένα αντίστροφο Java Naming and Directory Interface (JN-DI) αντί ένα αντικείμενο να ψάχνει μόνο του για τις εξαρτήσεις του σε έναν container, ο container δίνει τις εξαρτήσεις στο αντικείμενο χωρίς να περιμένει πρώτα να ερωτηθεί.
• Aspect - Oriented — Η Spring παρέχει πλούσια υποστήριξη σε Aspect - Oriented Programming (AOP). Αυτό έχει σαν αποτέλεσμα τη δημιουργία εφαρμογών με περισσότερη συνοχή ακόμη και αν είναι απαραίτητη η συνύπαρξη διαφορετικών λογικών λειτουργίας. ́Ετσι, κάθε αντικείμενο της εφαρμογής κάνει μόνο ό,τι το αφορά και δεν είναι υπεύθυνο (ενδεχομένως δε γνωρίζει καν) για πράγματα που έχουν να κάνουν με άλλα συστήματα. Τέτοιου είδους πράγματα μπορεί να είναι η υποστήριξη συνδιαλλαγών ή η καταγραφή των διαφόρων κινήσεων (logging).
• Container — Η Spring αποτελεί έναν container με την έννοια ότι κρατάει και διαχειρίζεται τον κύκλο ζωής και τη διαμόρφωση των αντικειμένων της εφαρμογής. Ο προγραμματιστής μπορεί να ορίσει πώς θέλει να διαμορφώνονται και να δημιουργούνται τα αντικείμενα, καθώς και ποιες θέλει να είναι οι σχέσεις μεταξύ τους.
• Framework (Περιβάλλον Εργασίας) — Η Spring δίνει τη δυνατότητα να δημιουργηθούν πολύπλοκες εφαρμογές με το συνδυασμό άλλων, λιγότερο πολύπλοκων, κομματιών. Στη Spring τα αντικείμενα δημιουργούνται μέσω δηλώσεων σε απλά XML αρχεία. Επίσης παρέχει πολλές δομικές λειτουργίες, όπως η διαχείριση συναλλαγών κ.ά., επιτρέποντας στον προγραμματιστή να ασχοληθεί περισσότερο με τη λογική της εφαρμογής του.

́Ετσι, μπορούμε να πούμε ότι η Spring είναι ένα περιβάλλον εργασίας το οποίο οηθάει τον προγραμματιστή να δημιουργήσει εφαρμογές με χαλαρά διασυνδεδεμένο κώδικα. Ακόμη και αν αυτό ήταν το μόνο που έκανε, τα οφέλη θα ήταν πάρα πολλά από άποψη συντηρησιμότητας και ελεγξιμότητας και θα άξιζε τον κόπο να γίνει χρήση της.́Ομως η Spring είναι πολλά περισσότερα. Περιέχει κομμάτια που χρησιμοποιούν DI και AOP και έτσι συνθέτουν μία αρκετά αξιόλογη πλατφόρμα στην οποία μπορούν να αναπτυχθούν εφαρμογές.

Τα modules της Spring

Το περιβάλλον εργασίας της Spring αποτελείται από αρκετά, καλά ορισμένα, κομμάτια (modules). Τα κομμάτια αυτά σαν σύνολο δίνουν στον προγραμματιστή ό,τι χρειάζεται, για να αναπτύξει enterprise εφαρμογές. ∆εν απαιτείται από τον προγραμματιστή να βασίσει όλη την εφαρμογή του πάνω στη Spring. Αντίθετα, του παρέχεται η δυνατότητα να επιλέξει όποια από τα modules πιστεύει ότι καλύπτουν τις ανάγκες του. Επιπλέον παρέχονται τρόποι σύνδεσης με άλλα περιβάλλοντα εργασίας και βιβλιοθήκες έτσι, ώστε ο προγραμματιστής να μη χρειαστεί να τα αναπτύξει από την αρχή.

́Οπως φαίνεται στο σχήμα ;;, όλα τα modules της Spring είναι χτισμένα πάνω από το ασικό της container — πυρήνα. Ο πυρήνας καθορίζει πώς δημιουργούνται τα beans, πώς αρχικοποιούνται και πώς γίνεται ο χειρισμός τους — κάτι που αποτελεί τις κυριότερες λειτουργίες της Spring. ́Ομως ο προγραμματιστής ενδι-αφέρεται περισσότερο για άλλα modules, αυτά που χρησιμοποιούν τον πυρήνα και τις υπηρεσίες που αυτός παρέχει.

Στη συνέχεια θα περιγράψουμε κάθε ένα από τα διάφορα modules της Spring.

Ο πυρήνας — core container

Ο πυρήνας της Spring παρέχει όλη τη βασική λειτουργικότητα του Spring Framework. Το module αυτό περιέχει το BeanFactory, το οποίο είναι ο θεμελιώδης container και η βάση με την οποία η Spring υλοποιεί το DI.

Το DAO module

Η δουλειά με JDBC συχνά περιλαμβάνει τη δημιουργία αρκετού κώδικα, ο οποίος κάνει βασικές και τετριμμένες ενέργειες όπως σύνδεση με τη βάση, δημιουργία κάποιας εντολής (statement), επεξεργασία του αποτελέσματος και κλείσιμο της σύνδεσης. Μέσω του Data Access Object (DAO) module η Spring δίνει τη δυνατότητα απλοποίησης όλης αυτή της διαδικασίας περιορίζοντας τα προβλήματα που προκύπτουν. Επιπλέον, χτίζει ένα layer από exceptions πάνω από τα μηνύματα σφάλματος που παράγουν αρκετοί εξυπηρετητές βάσεων δεδομένων.

Επιπρόσθετα, αυτό το module (χρησιμοποιώντας το AOP module) παρέχει υπηρεσίες διαχείρισης συναλλαγών για τα αντικείμενα των εφαρμογών που χρησιμοποιούν τη Spring.

Το ORM module

Για αυτούς που προτιμούν να χρησιμοποιούν το εργαλεία για object - relational mapping (ORM) (αντιστοίχηση σχέσης - αντικειμένου) αντί για την απευθείας χρήση του JDBC η Spring παρέχει το ORM module. Αυτό χτίζει πάνω στο DAO παρέχοντας έναν αρκετά ολικό τρόπο για ανάπτυξη DAO πάνω από αρκετές λύσεις που προσφέρουν object - relational mapping. Παρ ́ όλο που η Spring δεν παρέχει το δικό της ORM, υποστηρίζει αρκετά δημοφιλή περιβάλλοντα εργασίας, συμπεριλαμβανομένων των Hibernate, Java Persistence API, Java Data Objects και iBatis SQL Maps. Το σύστημα διαχείρισης συναλλαγών της Spring υποστηρίζει εκτός από αυτά τα περιβάλλοντα εργασίας και το JDBC.

Το AOP module

Η Spring προσφέρει υποστήριξη για aspect - oriented programming στο AOP module της. ́Οπως και το DI, το AOP υποστηρίζει τη χαλαρή διασύνδεση μεταξύ των αντικειμένων κάθε εφαρμογής, όμως με το AOP σημαντικά θέματα που αφορούν το σύνολο των εφαρμογών (όπως οι συναλλαγές και η ασφάλεια) χωρίζονται από τα αντικείμενα στα οποία αυτά εφαρμόζονται.

Το Web module

Η Spring παρέχει μία πλούσια συλλογή κλάσεων για τη δημιουργία εφαρμογών που στηρίζονται στο διαδίκτυο (web - based applications) μέσω του Web module της. Υποστηρίζεται η χρήση του προτύπου σχεδίασης εφαρμογών Model/View/Controller (MVC), ο χειρισμός ηλεκτρονικής αλληλογραφίας (mail support) καθώς και η χρήση απομακρυσμένων υπηρεσιών (remoting support).

'́Οσον αφορά τη χρήση του προτύπου σχεδίασης εφαρμογών Model/View/Controller (MVC), η Spring υποστηρίζει πλήρως το πιο γνωστό MVC περιβάλλον εργασίας, το Apache Struts. Με αυτόν τον τρόπο δίνεται η δυνατότητα στον προγραμματιστή να χρησιμοποιήσει στις ήδη σχεδιασμένες κλάσεις του τις αρχές του dependency injection που προσφέρει η Spring. Βέβαια, πέραν της υποστήριξης του Apache Struts, η Spring προσφέρει και τη δική της υλοποίηση του MVC.Μέσω αυτού μπορεί να γίνει χρήση μίας ευρείας γκάμας τεχνολογιών παρουσίασης, από σελίδες JSP και Apache Jakarta Velocity μέχρι Microsoft Excel και Adobe PDF.

Σε σχέση με την αποστολή μηνυμάτων ηλεκτρονικής αλληλογραφίας, η Spring παρέχει ένα αρκετά απλοποιημένο API, το οποίο ταιριάζει με την όλη φιλοσοφία του DI που αυτή προσφέρει. Για το σκοπό αυτό παρέχονται δύο υλοποιήσεις, μία του JavaMail και μία της MailMessage κλάσης από το πακέτο com.oreilly.servlet του Jason Hunter. Μέσω αυτών δίνεται η δυνατότητα δημιουργίας ενός πρότυπου μηνύματος το οποίο στη συνέχεια μπορεί να χρησιμοποιηθεί σαν βάση για την αποστολή αλληλογραφίας μέσω της εφαρμογής.

Τέλος, σε σχέση με χρήση απομακρυσμένων υπηρεσιών, παρέχεται εκτεταμένη υποστήριξη μίας μεγάλης συλλογής τεχνικών απομακρυσμένης πρόσβασης για τη γρήγορη δημιουργία και πρόσβαση σε απομακρυσμένες υπηρεσίες. Τέτοιες τεχνικές είναι το Java RMI, το JAXRPC, το Caucho Hessian και το Caucho Burlap. Εκτός αυτών, η Spring παρέχει και το δικό της πρωτόκολλο, που χρησιμοποιεί το HTTP πρωτόκολλο επικοινωνίας και το οποίο βασίζεται στο απλό Java serialization.

Java EE Connector API (JCA) Αν και τα τελευταία χρόνια όλο και περισσότεροι προγραμματιστές τείνουν να χρησιμοποιούν τις λεγόμενες ελαφριές πλατφόρμες με τεχνολογίες όπως η Spring και ο Tomcat, υπάρχουν πολλές περιπτώσεις όπου η χρήση αρκετών παραδοσιακών J2EE APIs κρίνεται απαραίτητη. Η σύνδεση και επικοινωνία μεταξύ τέτοιου είδους εφαρμογών και εφαρμογών που χρησιμοποιούν άλλες τεχνολογίες μπορεί να είναι δύσκολη. Το JCA της Spring παρέχει ένα σταθερό (stable) και αξιόπιστο τρόπο για την επικοινωνία με μία σειρά από τέτοιου είδους enterprise συστήματα. Τα κυριότερα APIs που υποστηρίζονται είναι το Java Naming and Directory Interface (JNDI), τα EJB καθώς και η Java Message Service (JMS).

́Ενα παράδειγμα

Το dependency injection είναι το πιο ασικό πράγμα που κάνει η Spring. Στη συνέχεια θα παρουσιαστεί μία απλή εφαρμογή, μία διαφοροποίηση του συνηθισμένου ‘‘Hello World’’, η οποία θα παρουσιάσει τα ασικά σημεία της Spring.

Η πρώτη κλάση που χρειάζεται η Hello World εφαρμογή είναι μία κλάση εξυπηρετητής (service class) ο σκοπός της οποίας είναι να τυπώσει το γνωστό χαιρετισμό. Παρακάτω φαίνεται το interface GreetingService το οποίο ορίζει τις συναρτήσεις της κλάσης εξυπηρετητή.

public interface GreetingService {
    void sayGreeting();
}

Ακολούθως παρουσιάζεται η συνάρτηση GreetingServiceImpl η οποία υλοποιεί (implements) το παραπάνω interface. Η χρήση interface για τον ορισμό των ενεργειών που μπορούν να γίνουν με τα διάφορα αντικείμενα δεν είναι απαραίτητη, εντούτοις η πολιτική αυτή συνιστάται.

public class GreetingServiceImpl implements GreetingService {
    private String greeting;
    public GreetingServiceImpl () {}
    public GreetingServiceImpl (String greeting) {
        this.greeting = greeting;
    }
    void sayGreeting() {
        System.out.println(greeting);
    }
    public void setGreeting(String greeting) {
        this.greeting = greeting;
    }
}

Η κλάση GreetingServiceImpl έχει μία μόνο μεταβλητή μέλος, την greeting. Αυτή είναι ένα απλό String το οποίο θα κρατάει τον χαιρετισμό που θα τυπωθεί, όταν θα καλεστεί η μέθοδος sayGreeting(). Επιπλέον έχει και δύο μεθόδους δημιουργούς, έναν κενό και έναν που παίρνει σαν όρισμα τον χαιρετισμό. Οποιοσδήποτε από τους δύο αυτούς δημιουργούς μπορεί να καλεστεί, ανάλογα με τις ρυθμίσεις που θα οριστούν. Παρακάτω φαίνεται το αρχείο ρυθμίσεων (configuration file) (hello.xml) το οποίο ορίζει στον πυρήνα της Spring πώς ακριβώς πρέπει να εκτελέσει την υπηρεσία που δημιουργήθηκε.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns=
         "http://www.springframework.org/schema/beans"
       xmlns:xsi="http://w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation=
         "http://www.springframework.org/
            shema/beans/spring-beans-2.0.xsd">
  <bean id="greetingService" class="GreetingServiceImpl">
      <property name="greeting" value="Hello World!">
  </bean>
</beans>

Στο παραπάνω αρχείο δηλώνεται ένα στιγμιότυπο της GreetingServiceImpl στον container της String στο οποίο ορίζεται ότι η μεταβλητή μέλος (property) θα έχει την τιμή ‘‘Hello World!’’.

Αναλύοντας λίγο τον παραπάνω XML κώδικα βλέπουμε ότι το root στοιχείο είναι το <beans>, κάτι που ισχύει για οποιοδήποτε αρχείο ρυθμίσεων της Spring. Το στοιχείο <bean> λέει στον container για μία κλάση και πώς αυτή πρέπει να αρχικοποιηθεί. Το χαρακτηριστικό (attribute) id του στοιχείου <bean> χρησιμοποιείται, για να ορίσει το όνομα του bean, ενώ το class χρησιμοποιείται για να οριστεί το ακριβές όνομα της κλάσης (class path).

Μέσα στο στοιχείο <bean> ορίζεται ένα στοιχείο <property> το οποίο χρησιμοποιείται, για να οριστεί μία μεταβλητή μέλος, σε αυτή την περίπτωση η greeting. Το στοιχείο property λέει στον πυρήνα να καλέσει την μέθοδο sayGreeting δίνοντάς της την τιμή ‘‘Hello World’’ κατά την αρχικοποίηση του bean.

Παρακάτω φαίνεται το τι είναι αυτό που κάνει ακριβώς ο πυρήνας κατά την αρχικοποίηση της υπηρεσίας σύμφωνα με το XML αρχείο ρυθμίσεων.

GreetingServiceImpl greetingService =
    new GreetingServiceImpl();
greetingService.setGreeting("Hello World!");

Αυτό που μένει είναι η δημιουργία μίας κλάσης η οποία να φορτώνει τον πυρήνα της Spring και να τον χρησιμοποιεί για την εκτέλεση της υπηρεσίας.

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.FileSystemResource;
public class HelloApp {
  public static void main(String[] args)
       throws Exception
  {
    BeanFactory factory = new XmlBeanFactory
        (new FileSystemResource("hello.xml"));
    GreetingService service = (GreetingService)
        factory.getBean("greetingService");
    service.sayGreeting();
  }
}

Η κλάση BeanFactory που χρησιμοποιείται παραπάνω αποτελεί τον πυρήνα της Spring. Μετά τη φόρτωση του hello.xml αρχείου από τον πυρήνα η main(·) καλεί τη μέθοδο getBean(·), ώστε να ανακτήσει τις εξαρτήσεις της υπηρεσίας.

'Εχοντας αυτές τις εξαρτήσεις καλείται τελικά η μέθοδος sayGreeting(·).́Οταν εκτελεστεί η εφαρμογή, όπως αναμενόταν, τυπώνεται το :

Hello World!

Η παραπάνω εφαρμογή αποτελεί το πιο απλό πιθανό παράδειγμα χρήσης της Spring. Παρά την απλότητά του παρουσιάζει το βασικό τρόπο ρύθμισης και χρήσης κλάσεων μέσω της Spring. ́Ομως, λόγω της απλότητάς του, δε δείχνει πώς μπορεί να ρυθμιστεί κάποιο bean, ώστε να περαστεί η τιμή ενός String στο πεδίο (injection). Η πραγματική δύναμη της Spring έγκειται στο πώς μπορούν τα διάφορα beans να συνδεθούν με άλλα beans κάνοντας χρήση του DI.

Κατανοώντας το dependency injection

Αν και η Spring έχει πολλές δυνατότητες, το DI αποτελεί την καρδιά του περιβάλλοντος εργασίας. Παρά το γεγονός ότι ο όρος αυτός ακούγεται σαν μια περίπλοκη προγραμματιστική τεχνική ή τρόπο σχεδιασμού (design pattern) στην πραγματικότητα δεν είναι τόσο πολύπλοκο όσο ακούγεται. Αντίθετα, η χρήση του κάνει τον κώδικα πολύ πιο απλό, ευκολονόητο και εύκολα συντηρήσιμο.

Κάθε μη τετριμμένη εφαρμογή (δηλαδή οτιδήποτε πιο πολύπλοκο από το κλλασικό παράδειγμα HelloWorld.java) αποτελείται από δύο ή περισσότερες κλάσεις οι οποίες συνεργάζονται, για να εκτελέσουν τις απαραίτητες ενέργειες. Παραδοσιακά κάθε αντικείμενο είναι υπεύθυνο να διατηρεί τις αναφορές του (reference) στα αντικείμενα με τα οποία ‘συνεργάζεται’ (δηλαδή τις εξαρτήσεις του — dependencies). Κάτι τέτοιο οδηγεί σε έναν ισχυρά δεμένο και δύσκολο στον έλεγχο κώδικα.

́Οταν γίνεται χρήση του DI, τα αντικείμενα λαμβάνουν τις εξαρτήσεις τους κατά την ώρα της δημιουργίας τους από μία εξωτερική οντότητα η οποία συντονίζει κάθε αντικείμενο στο όλο σύστημα. Με άλλα λόγια, οι εξαρτήσεις (dependencies) δίνονται (injected) στα αντικείμενα. ́Ετσι, το DI αποτελεί ενός είδους αντιστροφής στην ευθύνη που αφορά τη διατήρηση των αναφορών των αντικειμένων. Η λειτουργικότητα αυτή παρέχεται από τον πυρήνα της Spring, ο οποίος είναι υπεύθυνος να δίνει στα αντικείμενα τις εξαρτήσεις τους. Ο πυρήνας γνωρίζει πώς πρέπει να δώσει αυτές τις εξαρτήσεις στα κατάλληλα αντικείμενα διαβάζοντας το XML αρχείο υθμίσεων της Spring.

Το κλειδί της παραπάνω τεχνικής είναι η χαλαρή διασύνδεση. Αν ένα αντικείμενο γνωρίζει για τις εξαρτήσεις του μόνο μέσω μίας διεπαφής (όχι μέσω της υλοποίησής τους ή μέσω του τρόπου που δημιουργούνται), η εξάρτηση μπορεί να αλλαχτεί πολύ εύκολα από μια διαφορετική υλοποίηση χωρίς το αντικείμενο να γνωρίζει για τη διαφορά.

Aspect-Oriented Programming

'́Οπως περιγράφηκε στην προηγούμενη παράγραφο, το DI καθιστά εφικτή τη χαλαρή διασύνδεση τμημάτων λογισμικού σε εφαρμογές. Αντίθετα, το aspect-oriented programming επιτρέπει τη συγκέντρωση λειτουργιών οι οποίες χρησιμοποιούνται σε όλη την εφαρμογή σε επαναχρησιμοποιήσιμα κομμάτια.

Το aspect-oriented programming συχνά ορίζεται ως μια τεχνική η οποία προάγει το διαχωρισμό ευθυνών μέσα στο σύστημα λογισμικού. Τα συστήματα αποτελούνται από πολλά ξεχωριστά κομμάτια το καθένα από τα οποία είναι υπεύθυνο για συγκεκριμένο κομμάτι λειτουργικότητας. Συχνά όμως αυτά τα κομμάτια έχουν επιπλέον ευθύνες πέρα από τις βασικές λειτουργίες για τις οποίες προορίζονται. Υπηρεσίες όπως η διατήρηση αρχείου, η διαχείριση συναλλαγών και η ασφάλεια συχνά υλοποιούνται μέσα σε κομμάτια λογισμικού των οποίων η βασική ευθύνη είναι τελείως διαφορετική.

Μοιράζοντας τέτοιου είδους ευθύνες κατά μήκος πολλαπλών κομματιών κώδικα δημιουργούνται δύο επίπεδα πολυπλοκότητας στον κώδικα που αναπτύσσεται :

• Ο κώδικας ο οποίος υλοποιεί λειτουργίες που αφορούν όλη την εφαρμογή είναι διασκορπισμένος σε πολλά διαφορετικά τμήματα κώδικα αντί να είναι συγκεντρωμένος. Αυτό σημαίνει ότι, αν ο προγραμματιστής αποφασίσει να αλλάξει τον τρόπο που εκτελούνται τέτοιου είδους λειτουργίες, πρέπει να ανατρέξει σε πολλά διαφορετικά κομμάτια. Ακόμα και αν η διαφοροποίηση έγκειται μόνο στην αλλαγή του τρόπου κλήσης μίας και μόνο μεθόδου, η διόρθωση θα πρέπει να γίνει σε πολλά διαφορετικά κομμάτια κώδικα.
• Τα διάφορα κομμάτια κώδικα είναι επιφορτισμένα με λειτουργίες οι οποίες δεν τα αφορούν προσθέτοντάς τους επιπλέον κώδικα. Για παράδειγμα, αν η λειτουργία μίας μεθόδου είναι να προσθέσει μία εγγραφή σε έναν τηλεφωνικό κατάλογο, δεν πρέπει να την αφορά το αν αυτή η διαδικασία γίνει με ασφάλεια.

Το AOP κάνει εφικτό το διαχωρισμό των διαφόρων υπηρεσιών επιτρέποντας να γίνεται χρήση τους, όποτε κάτι τέτοιο κρίνεται επιθυμητό, από τα κομμάτια κώδικα (components) που τις χρειάζονται. Αυτό οδηγεί στην ανάπτυξη πιο συνεκτικών κομματιών τα οποία είναι περισσότερο συγκεντρωμένα στο βασικό τους στόχο, αγνοώντας τελείως τις διάφορες άλλες υπηρεσίες του συστήματος. Με λίγα λόγια η χρήση των aspects διασφαλίζει ότι τα POJOs θα παραμείνουν απλά (plain).