Google Guice - AOP

---

AOP, aspektorientierte Programmierung bedeutet, die Programmlogik in verschiedene Teile zu zerlegen, die als sogenannte Anliegen bezeichnet werden. Die Funktionen, die sich über mehrere Punkte einer Anwendung erstrecken, werden als Querschnittsthemen bezeichnet, und diese Querschnittsthemen sind konzeptionell von der Geschäftslogik der Anwendung getrennt. Es gibt verschiedene Beispiele für Aspekte wie Protokollierung, Prüfung, deklarative Transaktionen, Sicherheit, Caching usw.

Die Schlüsseleinheit der Modularität in OOP ist die Klasse, während in AOP die Einheit der Modularität der Aspekt ist. Mithilfe der Abhängigkeitsinjektion können Sie Ihre Anwendungsobjekte voneinander entkoppeln, und mit AOP können Sie Querschnittsthemen von den betroffenen Objekten entkoppeln. AOP ist wie Trigger in Programmiersprachen wie Perl, .NET, Java und anderen. Guice bietet Interceptors zum Abfangen einer Anwendung. Wenn beispielsweise eine Methode ausgeführt wird, können Sie vor oder nach der Methodenausführung zusätzliche Funktionen hinzufügen.

Wichtige Klassen

• Matcher- Matcher ist eine Schnittstelle zum Akzeptieren oder Ablehnen eines Werts. In Guice AOP benötigen wir zwei Matcher: einen, um zu definieren, welche Klassen teilnehmen, und einen, um die Methoden dieser Klassen zu definieren.

• MethodInterceptor- MethodInterceptors werden ausgeführt, wenn eine übereinstimmende Methode aufgerufen wird. Sie können den Aufruf überprüfen: die Methode, ihre Argumente und die empfangende Instanz. Wir können eine Querschnittslogik durchführen und dann an die zugrunde liegende Methode delegieren. Schließlich können wir den Rückgabewert oder die Ausnahme überprüfen und zurückgeben.

Beispiel

Erstellen Sie eine Java-Klasse mit dem Namen GuiceTester.

GuiceTester.java

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.Inject;
import com.google.inject.Injector;
import com.google.inject.matcher.Matchers;

public class GuiceTester {
   public static void main(String[] args) {
      Injector injector = Guice.createInjector(new TextEditorModule());
      TextEditor editor = injector.getInstance(TextEditor.class);
      editor.makeSpellCheck(); 
   } 
}

class TextEditor {
   private SpellChecker spellChecker;

   @Inject
   public TextEditor(SpellChecker spellChecker) {
      this.spellChecker = spellChecker;
   }

   public void makeSpellCheck(){
      spellChecker.checkSpelling();
   }
}

//Binding Module
class TextEditorModule extends AbstractModule {

   @Override
   protected void configure() {
      bind(SpellChecker.class).to(SpellCheckerImpl.class);
      bindInterceptor(Matchers.any(), 
         Matchers.annotatedWith(CallTracker.class), 
         new CallTrackerService());
   } 
}

//spell checker interface
interface SpellChecker {
   public void checkSpelling();
}

//spell checker implementation
class SpellCheckerImpl implements SpellChecker {

   @Override @CallTracker
   public void checkSpelling() {
      System.out.println("Inside checkSpelling." );
   } 
}

@Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD)
@interface CallTracker {}

class CallTrackerService implements MethodInterceptor  {

   @Override
   public Object invoke(MethodInvocation invocation) throws Throwable {
      System.out.println("Before " + invocation.getMethod().getName());
      Object result = invocation.proceed();
      System.out.println("After " + invocation.getMethod().getName());
      return result;
   }
}

Ausgabe

Wenn Sie die Datei kompilieren und ausführen, wird möglicherweise die folgende Ausgabe angezeigt.

Before checkSpelling
Inside checkSpelling.
After checkSpelling