Aspect-georiënteerde programmeervoorbeelden

Kan iemand een voorbeeld posten van Aspect-oriented programming (AOP) dat geenlogging is?

Ik heb verschillende bronnen bekeken, maar alle voorbeelden zijn triviale logboekregistratie. Waar is het nuttig voor?


Antwoord 1, autoriteit 100%

Een van de voorbeelden die rechtstreeks uit deze Aspect Oriented Programming: Radical Research in Modularity, Youtube videoschilderde naar een scherm. In het voorbeeld heb je een tekenprogramma, dat bestaat uit punten, vormen, enz. en wanneer er wijzigingen in die objecten optreden, moet je het scherm vertellen om zichzelf bij te werken. Zonder het in een bepaald aspect aan te pakken, herhaal je jezelf nogal wat.

AOP, zoals ik het heb begrepen, is gemaakt om jezelf niet te herhalen voor transversale zorgen die misschien niets te maken hebben met bedrijfslogica. Met aspecten kun je deze zorgen moduleren tot aspecten. Een van de voorbeelden was loggen, maar er zijn een heleboel verschillende dingen die je zou kunnen herhalen. Het is sindsdien geëvolueerd en het gaat niet meer om aspectgericht programmeren, maar er is ook aspectgericht modelleren.

Meer informatie over aspectgeoriënteerd programmeren is te vinden in deze bronnen:


Antwoord 2, autoriteit 31%

Beveiliging

  • Injecteer code die machtigingen controleert en toegang blokkeert

Vriendelijkere foutberichten voor asp.net webcontrols/webparts

Prestaties

  • Injecteer code die prestatietellers instelt om een ​​overzicht te krijgen van waar uw app traag is

Antwoord 3, autoriteit 17%

Validatie:

[NotNull]
public string Property1 { get; set; }
[Length(Min = 10, Max = 20)]
public string Property2 { get; set; }
[Regex(Expression = @"[abc]{2}")]
public string Property3 { get; set; }

4, Autoriteit 14%

Een ander klassiek voorbeeld (zoals loggen) is caching. Maar andere voorbeelden zijn interessanter.


5, Autoriteit 9%

Beveiliging – Controleren dat gebruikers passende machtigingen hebben voordat ze bepaalde methoden uitvoeren.


6, Autoriteit 9%

U kunt geen meerdere overerving in Java hebben. Maar door een AOP te gebruiken, kunt u “beperkte” meerdere erfenis hebben.
Probeer dit te Google om enkele voorbeelden te bekijken.

Ik ben het ook eens met eyvid. Hannemann en Kiczales-papier is geweldig voor het leren van de basis op designpatronen en het krijgen van een aantal geweldige AOP-voorbeelden.


7, Autoriteit 6%

Public Invariant Checking. Aangezien Postsharp 1.5 zal worden geleverd met aspect-erfenis, zelfs via interfaces, geeft het veel nieuwe kansen.


8, Autoriteit 6%

Mijn fotoalbum gebruikt aspectj voor drie dingen:

  1. implementeren van de waarnemer “Patroon” als een herbruikbaar stuk code.
  2. een sessie vernietigen voor een specifiek type gesprek.
  3. Dirty vlaggen instellen op DTO’s wanneer mutatie plaatsvindt.

De eerste, in het bijzonder was vrijwel vrij recht uit een Google Tech praten op AOP . Het gaat over modulariteit op een andere manier dan de meeste mensen overwegen. Aanbevolen om dat te bekijken als je geïnteresseerd bent om het voorgoed te gebruiken.


9, Autoriteit 6%

Transactiebeheer.

Naar mijn mening wil je geen objecten die deel kunnen uitmaken van een transactie om zich ervan bewust te zijn dat ze in een transactie zijn. Als u AOP gebruikt, kunt u objecten in transacties samenstellen, zoals vereist zonder de objecten in de transactie die op de hoogte is van het feit dat zij in een transactie of zelfs van het bestaan ​​van het AOP-raamwerk zijn.


10, Autoriteit 6%

Ik heb aspect-georiënteerde programmering gebruikt om een ​​zoekmachine-zoekmachine te implementeren. Het leek meer op een experiment, maar het laat zien hoe AOP kan worden gebruikt voor andere doeleinden dan loggen en traceren.

eigenlijk:
(i) de gebruiker van de motor markeert zijn / haar lessen als trefwoordsarchable,
(ii) de motor begint met het bijhouden van de creatie & amp; Vernietiging van deze sleutelwoordverschillende instanties,
(iii) De engine haalt de trefwoorden uit deze KeywordSearchable-objecten,
(iv) Gezien de objecten en de trefwoorden, zorgt het algoritme voor de zoekopdracht.

Meer details hierover zijn te vinden op http://montrealistic.blogspot.com/2011/08/aspect -oriented-implementation-of.html.


Antwoord 11, autoriteit 6%

Voorbeelden van AOP:

  • Een parser en beoordelaar voor rekenkundige uitdrukkingen. Dit had geprogrammeerd kunnen worden met behulp van het bezoekerspatroon, maar ik denk dat aspecten een beter alternatief zijn.
  • Een eenvoudige teksteditor, waarin sommige beheertaken (bijv. het onderhouden van de vlag “bestand is gewijzigd” en het onderschrift van het venster) als afzonderlijke aspecten worden behandeld.
  • Een gegevensstructuur voor tekenreeksen, waarin tekenreeksen worden weergegeven als bomen, zodat aaneenschakeling en selectie van subtekenreeksen kunnen worden geïmplementeerd zonder te kopiëren. Om de efficiëntie te behouden, moeten de bomen soms opnieuw in evenwicht worden gebracht; de balanceringscode wordt als een aspect behandeld.

Stel je voor dat je een bericht wilt loggen binnen de methoden van je domeinmodel:

Voorbeeld: loggen zonder AOP:

namespace Examples\Forum\Domain\Model;
class Forum {
    /**
     * @Flow\Inject
     * @var \Examples\Forum\Logger\ApplicationLoggerInterface
     */
    protected $applicationLogger;
    /**
     * Delete a forum post and log operation
     *
     * @param \Examples\Forum\Domain\Model\Post $post
     * @return void
     */
    public function deletePost(Post $post) {
            $this->applicationLogger->log('Removing post ' . $post->getTitle(), LOG_INFO);
            $this->posts->remove($post);
    }
}

Als u dit op veel plaatsen moet doen, zou de logboekregistratie een onderdeel worden van de logica van uw domeinmodel. U zou alle logboekafhankelijkheden in uw modellen moeten injecteren. Aangezien loggen niets is waar een domeinmodel zich druk om moet maken, is dit een voorbeeld van een niet-functionele vereiste en een zogenaamd transversaal probleem.

Met AOP zou de code in uw model niets weten over logboekregistratie. Het zal zich alleen concentreren op de bedrijfslogica.

Other episodes