interceptorok, egy lehetseges implementacio antares felett

de elosszor is: mire jo ez az egesz?

tegyuk fel, hogy le akarjuk merni, hogy mennyi ideig fut egy adott metodus. hogy csinaljuk ezt? peldaul teletomhetjuk loggolo koddal, ami megnezi azi idot amikor meghivodott a metodus, es megnezi ami elott visszater, majd leloggolja a kulonbseget, azonban ehez egyreszt rendelkeznunk kell az adott osztaly forraskodjaval (ez sok helyen ugyis adott), masreszt ha csak debug idejere szeretnenk ezt a funkcionalitast, akkor miutan elesbe megy a projekt, irhatjuk at a kodot. szoval bonyis.

a masik megoldas, hogy beburkoljuk egy dinamikus proxyval, ami mindaddig jo, amig nem valami menedzselt kornyezetben (pl alkalmazasszerver futunk). itt mar eleg veszelyes dolog egy ilyen, ki tudja hol borulunk meg (Java SE kornyzetben siman jo megoldas amugy, lehet szep, dinamikus Decorator Patternt implementalni vele).

Java EE -s kornyezetben definialhatunk interceptor osztalyt a beanunkre, es akkor szepen meglehet mondani melyik metodus hivodjon meg az eredeti meghivasa helyett (szo szerint elkapjuk a hivast: ha akarjuk, megoldhato az is, hogy az eredeti objektum metodusa le se fusson).

Antaresben is szerettem volna ilyen featuret implementalni. A kovetkezo peldan megertheto, hogy mi is ez, es hogy mukodik.

Tegyuk fel, hogy van egy nagyon egyszeru interfeszunk:

public interface Hello {
    public void sayHello();
}

es az ot implementalo osztaly:

public class HelloImpl implements Hello {
    public void sayHello() {
        System.out.println("HAI!");
    }
}

es persze van egy harmadik osztaly, ami szeretne ezt hasznalni. itt kezdodnek a trukkok :-)

public class HelloUser {
    @Inject(strategy=InjectionStrategy.FromManagedPool,
            interceptor=TestInterceptor.class,
            interceptorInjectionStrategy=InterceptorInjectionStrategy.Keep)
    private Hello hello;

    public void use() {
        hello.sayHello();
    }
}

sok ronda dolog van itt, elosszor is kezdjuk az Inject annotacioval. azt mondja, hogy szeretne egy Hello interfeszt implementalo peldanyt injektalni a helloba. nyilvan az injektalast majd egy kontener vegzi, errol egyelore tobbet nem beszelnek, most nem azon van a hangsuly, hanem ket annotacios parameteren: az interceptoron es az interceptorInjectoinStrategyn.

az elso azt mondja meg, hogy szeretnenk ugy injektlani az adott interfeszimplementaciot, hogy az interceptorunkkal el tudjuk kapni, a strategia pedig az, hogy az injekciot vegzo proxy (mert ugye minden kontenerben proxyval csinaljak ezeket :)) hozzon letre egy peldanyt, es ne minden metodushivasnal csinaljon egyet.

nezzuk meg magat az interceptort:

public class TestInterceptor {
    private long start;

    public TestInterceptor() {
        System.out.println("interceptort letrehoztak!!");
    }

    @BeforeInvoke
    public void x(InvocationContext ctx) {
        start = System.currentTimeMillis();
    }

    @AfterInvoke
    public void y(InvocationContext ctx) {
        System.out.println("invocation of " + ctx.getTargetMethod().getName() +
                " on an instance of " + ctx.getTargetInstance().getClass().getCanonicalName() +
                " took " + (System.currentTimeMillis() - start) + " milliseconds");
    }
}

ez a kod azthiszem egyertelmu; az eredeti peldany metodushivasa elott meghivodik az interceptorpeldany megfelelo metodusa, es utana is egy masik metodusa. (persze lehetne ugyanaz is, ha oda raknank az annotaciokat..)
ez az interceptor egyszeruen annyit csinal, amit fent is vazoltam: lemeri mennyi ido volt meghivni a metodust.

az ezeket hasznalo foprogram:

public class Main {
    public static void main(String[] args) {
        Container container = new Container();
        container.addManagedInstance(new HelloImpl());

        try {
            HelloUser user = container.getInstance(HelloUser.class);
            if(user == null) {
                System.out.println("null volt!");
            } else {
                user.use();
            }
        } catch(InjectionException e) {
            e.printStackTrace();
        }
    }
}

es amit kiir futas utan:

interceptort letrehoztak!!
HAI!
invocation of sayHello on an instance of antaresuse.HelloImpl took 4 milliseconds

melyik a konnyebb, kivenni azt a ket annotacioparametert, vagy atirni egy osztaly mondjuk 50 metodusat? :-)