o m

i.c
LG YE YÖNEL K PROGRAMLAMA VE
ASPECTJ
dil
(ASPECT OR ENTED PROGRAMMING AND ASPECTJ)
va
Hikmet DÜZGÜN
Hacettepe Üniversitesi Bilgisayar Mühendisli.i
Bölümü
ja
w.
ww

1
 m
Ç NDEK LER

1. G R 3 ………………………………………………………………………………….. 3
2. AOP MANTI7INA G R 3 VE TEMEL KAVRAMLAR……………………………….. 4

o
3. BIRLESME NOKTALARI (JOIN POINTS) VE BIRLESIM NOKTA KÜMELER
(POINTCUTS) ……………………………………………………………………………… 5

i.c
4. DOKUMA (WEAVING) …………………………………………………………………... 6
5. ASPECTJ …………………………………………………………………………………… 6
5.1. ASPECTJ HAKKINDA ……………………………………………………………… 6
5.1.1. DINAMIK BIRLESME NOKTASI MODELI (DYNAMIC JOIN POINT
MODEL) ………………………………………………………………………… 8

dil
5.1.2. BIRLESIM NOKTA KÜMELERI (POINTCUTS) …………………………… 8
5.1.3. TAVS YE-YORDAM (ADVICE) …………………………………………… ...10
5.1.4. DAH L -TÜR TANIMLARI (INTER-TYPE DECLARATIONS) …………...11
5.1.5. LG LER (ASPECTS) …………………………………………………………...12
5.2. GELISTIRME PLATFORMU (UYGULAMALI TANITIM) ……………………..13
va
6. AOP VE DIGER PROGRAMLAMA MODELLERI ……………………………………26
7. AOP PROBLEMLERI ……………………………………………………………………..26
8. KAYNAKÇA ……………………………………………………………………………….27
ja
w.
ww

2
 GR 3

m
Bu belgede, AOP mant na basit bir giri yap lacak, bir JAVA gerçekle tirimi olan AspectJ ve
uygulamas na yönelik özet bilgi verilecektir.

AOP, geleneksel programlama dillerinin kar la t klar özel sorunlara (crosscutting concerns – belge
içerisinde ayr nt l bir ekilde de inilecek ) kolay çözümler getirememeleri nedeniyle ortaya ç km t r. AOP

o
geçmi i tüm dünyada çok eskilere kadar dayanmas na ra men çok fazla ilgi görmemesi nedeniyle yava bir
geli me göstermi ve çok fazla kullan m olmam t r. Her bilgisayar mühendisi ya da programc s n n
gelecekte ö renmek için takvimine koydu u ama biço unun zaman ay rmad ya da ay ramad bir
gerçektir. Yine de her geçen gün, gerçekle tirilen uygulamalar n büyümesi dolay s yla bu tür sorunlarla

i.c
daha fazla kar la lmas nedeniyle önemi, dolay s yla da kullan m artmaktad r. En fazla AOP’ye ilgi
uygulama sunucular alan nda olmakta, hatta JBoss 4.0 uygulama sunucusunda a rl kl olarak AOP
kullan lm t r.

AspectJ, AOP mant n ta yan bir JAVA gerçekle tirimidir. Eclipse projesi kapsam nda yürütülen
projelerden biridir ve gerekli bir tak m eklemelerin yap lmas yla Eclipse platformu üzerinde kodlan p
çal t r labilir. Crosscutting sorunlara etkili çözümler getirmesi, debugging imkan vermesi ve JAVA
deste i gibi durumlar sayesinde di er AOP gerçekle tirimlerine göre daha yayg n bir kullan m olmu tur.

dil
Bu nedenle en bilinen AOP gerçekle tirimidir. Bu dökümanda, AspectJ’ye k sa bir giri yap lacak, basit
örnekler üzerinden ilgili kavram ve yap lar anlat lacak, Eclipse platformu üzerinde küçük bir kodun yaz l p
çal t r lmas ekran görüntüleriyle anlat larak geli tirme platformu hakk nda bilgi verilecek, en son da
AspectJ’nin kar la t problemlere de inilecektir.
ja va
w.
ww

3
 AOP MANTIGINA GIRIS VE TEMEL KAVRAMLAR

m
Aspect-oriented programming(AOP) di er bir ad yla aspect-oriented software development(AOSD), bir
program mümkün oldu unca farkl özellikler gösteren parçalara bölmeyi hedefleyen bir yakla md r.
Türkçeye "ilgiye yönelik programlama, ba lam yönelimli programlama ya da kesit yönelimli
programlama" diye de çevrilebilir fakat anlat m kolayl aç s ndan metin içerisinde AOP olarak yer
alacakt r. AOP, daha çok modulasyon ve sarma(encapsulation-ayr nt y kullan c dan basit bir arayüz ile

o
saklama) konular üzerinde durur.

Nesneye yönelik programlama da sarma(encapsulation) üzerinde odaklanmas na ra men kimi

durumlarda(crosscutting concerns) yeterli olmamaktad r. Loglama(log olu turma) bu tür durumlara örnek

i.c
olarak verilebilir çünkü; loglama stratejisi sistemdeki loglanm her bir parçay etkiler. Bu nedenledir ki
loglama, tüm loglanm s n f, yordam ve prosedürü enine keser yani program içerisinde birçok kez ayn
i levi yapmak maksad yla tekrarlan r.

AOP uygulamas bu tür durumlar n üstesinden gelmek üzere aspect(ilgi) diye adland r lan bir yap tan mlar.
=lgi, ilgi(aspect) yap da bulunmayan kod(base code) davran lar üzerinde de i iklik yapabilir. Bunu da
birle me noktalar (join points) üzerinde ek davran lar belirleme yoluyla gerçekle tirir.

dil
Cross-cutting concerns di er bir deyi le aspect (ilgi), program içersinde defalarca tekrar eden birbirinden
ba ms z modüllerce varolan program parçac klar olarak da görülebilir.

Örne in, bir hesaptan ba ka bir hesaba para transferi yapacak basit bir yordama sahip bir banka uygulamas
dü ünelim :

void transfer(Hesap hesaptan, Hesap hesaba, int miktar) {

if (hesaptan.getBakiye() < miktar) {
va
throw new YetersizBakiyeException();
}

hesaptan.dus(miktar);
hesaba.yatir(miktar);
}

Fakat bu tarz bir uygulaman n gerçek hayatta yukar daki kadar kolay bir yordamla yap lamayaca aç kt r.
ja

Öncelikle hesap sahip sahibinin böyle bir i levi yerine getirmek için yetkisinin olup olmad n n kontrol
edilmesi, i lem an nda do abilicek herhangi bir sorun nedeniyle sistemde kar kl k ya amamak maksad yla
i lemin database transaction aras na al nmas ve loglanmas gerekir. Bütün bu kayg lar (concerns)
ta yan basit bir uygulama a a daki gibi dü ünülebilir :

void transfer(Hesap hesaptan, Hesap hesaba, int miktar) {

w.

if (!getKullan c ().gerçekle tirebilir(!"_TRANSFER)) {

throw new GüvenlikException();
}
if (hesaptan.getBalance() < amount) {
throw new YetersizBakiyeException();
}
Transaction tx = database.newTransaction();
ww

try {
hesaptan.dus(miktar);
hesaba.yatir(miktar);
tx.üstlen();
systemLog.log! lem(!"_TRANSFER, hesaptan, hesabat, miktar);
}catch(Exception e) {
tx.geriSar();
}}

4
 Böylelikle kod ilk görünümünden dolay s yla da basit ve anla l r halinden fazlas yla uzakla m olur.

m
Birçok yeni durum (concern) koda gömülmek durumunda kal r. Bu da yordam n üstlenmesi gereken as l
i ten yani fonksiyonundan görünürde uzakla mas na neden olur. Bu nedenle, database transactions,
güvenlik ve loglama i lemleri yapt klar bu etkiler nedeniyle cross-cutting concerns’e örnek olarak
verilebilirler.

Diyelim ki sistemin güvenlik yönetiminde de i iklik yap lmas gerekiyor. Bu durumda güvenli in ele

o
al nd tüm kod parçac klar n n yeni duruma göre uyarlanmas gerekir. Tüm sisteme yay lm bir durum
üzerinde günleme yap lmas n n yüksek bir maliyete sahip oldu u gözden kaçamayacak derecede
belirgindir.

i.c
Anla laca üzere, ilgilerin (cross-cutting concerns) ele al n sistem temelinde yer ald dü ünülen
durumlar n ele al n kadar kolay degildir. Bu nedenledir ki AOP, bu tür ilgilerin çözümüne ili kin
birbirinden ba ms z, aspect (ilgi) olarak adland r lan yap lar tan mlar. Neredeyse tüm AOP dillerinde, bir
aspect di er programlama dillerinde yer alan yordam benzeri bir yap ya sahip advice (tavsiyeyordam)’lar
ve bu tavsiyeyordamlar n dokuyaca (weave) bir dizi join points (birle me noktalar )içerir.

BIRLESME NOKTALARI(JOIN POINTS) VE BIRLESIM NOKTA KÜMELERI(POINTCUTS)

dil
Temelde, bir ilginin ana (base) kodla etkile imi Join Point Model (JPM – Birle me Noktas Modeli) olarak
tan mlan r. Bir JPM üç ey tan mlar:
- Ilgi nerelerde uygulan r. Buralar genelde join points (birle im noktalar ) olarak bilinir.
- Çoklu birle im noktalar n belirlemek için bir yol. Pointcuts (birle im nokta kümeleri) olarak da
bilinir. Birle im nokta kümeleri, sistemdeki tüm birle im noktalar ndan bir alt kümeyi seçmek maksad yla
yap lan sorgular olarak da dü ünülebilir.
- Birle im noktalar üzerinde bir tür davran a etki yöntemi. AspectJ dilinde advice
va
(tavsiyeyordam) olarak da bilinir.

AspectJ programlama dilindeki JPM kapman nda dü ünülen birle im noktalar , bir program n çal mas
sürecinde oldukça iyi tan mlanm noktalard r. Bunlar: method çal mas (method execution), bir nesneye
de er atama (instantiation of an object) ve ayk r durum f rlatma ( throwing an exception). Görülece i
üzere, belirtilen birle im noktalar ancak program çal mas esnas nda farkedilebilecek durumlard r. Bu
nedenle AspectJ programlama dilinde, birle im noktalar kümesi ve önerimethod (advice) JPM dynamic
join point model (dinamik birle im noktas modeli) olarak da bilinir.
ja

Birle me noktalar kümesi program üzerinde yap lan bir sorgu sonucu belirlenir. Örnek bir birle im nokta
kümesi a a da gösterilmi tir:

pointcut set() : execution(* *.set*(..) ) && this(Nokta);

w.

Nokta tipinde bir nesne çal ma a amas nda (execute) ise, “set” ile ba layan çal ma (execution)
durumunda olan tüm yordamlar bu birle im nokta kümesinde belirlenir.

Advice (tavsiyeyordam)’lar JAVA programlama dilindeki yordamlara benzer bir ekilde belirlenirler, fakat
onlar gibi d ar dan (explicitly) ça r lamazlar. Ancak, kendilerine ili tirilen birle im nokta kümesi do ru
(true) döndü ü taktirde kendili inden ça r l rlar (implicitly). Örne in;
ww

after() : set() {
Görüntüle.güncelle();
}

Yukaridaki koda göre, ancak set() birle im nokta kümesi true olduktan sonra tavsiye-yordam gövdesi
i letilir.

5
 AspectJ’de kullan lan bir di er JPM de inter-type declarions (dahili-tür tan mlar ) d r. Bu mekanizma, bir

m
ilginin herhangi bir s n fa ya da nesneye ekstra tan mlar katmas n sa lar. Bu kavram aç k s n f olarak da
bilinir. Örnek bir dahili-tür tan m a a daki gibidir :

aspect MisafirKabul {
Nokta.misafirKabulEt(Misafir m) {
m.ziyaretEt(this);

o
}
}

Bu kod parçac , Nokta s n f na misafirKabulEt yordam n ekler.

• Birle me noktalar n n hepsi non-anonymous türdendir.

i.c
• Birle im nokta kümeleri s n f ya da arayüz (interface) adlar d r.
• Gövde tan mlar n n türe eklenmesiyle birle im nokta kümelerine etki edilebilir.

DOKUMA(WEAVING)

Dokuma, tavsiyeyordam belirtilen birle me noktalar na uygulama olarak dü ünülebilir. Orjinal AOP

• Bir kaynak ön i lemci (preprocessor)

dil
tan m nda, Kiczales ve tak m dokuma için a a daki ihtimalleri s ralam lard r :

• =kil kütükleri (binary files) yamayacak bir son i lemci (post processor)
• Dokunmu ikil kütükleri tan yan bir AOP derleyici
• Yükleme zaman dokuma ( örne in, JAVA’ya göre, ilgili tavsiyeyordam n JAVA’da s n flar n
JVM’e yüklendi i gibi dokunmas )
• Çal ma zaman dokuma ( çal ma zaman nda her bir birle me noktas n n yakalanmas ve ilgili
va
tavsiyeyordam n çal t r lmas )

=lk iki seçenek geli tirme i lemini zorla t r rken son ikisi de program n çal mas n yava lat r. Ayr ca son
seçenek, aspect (ilgi)tan yan bir çal ma ortam na (JVM gibi) ihtiyaç duyar.

Son seçenek d nda tan mlanan tüm seçenekler kod üzerinden herhangi bir noktada de i ikli e yol açarlar.
Yükleme zaman dokuman n ard ndan derlenmi JAVA ikil kütükleri içerisinde dokunmu tavsiyeyordam
parçac klar bulunur. Birçok programc bunu AOP’nin bir sak ncas olarak görür.
ja

Ba ka bir yöntem ise varolan kod üzerinde herhangi bir de i iklik yapmak yerine, s n flara ek alt s n flar
yaratma yani deploy-time weaving (yerle tirme zaman dokuma)’dir. Bu yöntemle varolan s n flara ait
yordamlar yarat lan alt s n flarca override edilir. Bu ekilde önceki kod de i meden kald ndan hata
ay klay c (debugger) vb. araçlar kullan lmaya devam edilir.
w.

ASPECTJ

AspectJ HakkDnda

AspectJ, kullan m oldukça kolay, JAVA platform uyumlu bir AOP JAVA gerçekle tirimidir. Crosscutting
sorunlar için kolay bir modülarizasyon imkan sunmakla birlikte, hata kontrolü ve ele al n ,
ww

senkronizasyon, performans iyile tirmeleri, loglama ve hata ay klama gibi durumlarda da oldukça
iddial d r.

AspectJ gerçekle tiriminin kolay anlat m n sa lamak üzere bir örnek üzerinden gitmenin daha mant kl
olaca inanc nday m. Bu maksatla, AspectJ gerçekle tirim özelliklerini vermek üzere bir Kekil Düzenleme
Sistemi kullan lacakt r.

6
 Bir Eekil bir veya daha fazla nokta ya da do.rudan olu ur. Kekil s n f factory hizmetini sa layacak ekilde

m
düzenlenmi tir. Bu sistem için UML gösterimi a a daki gibidir.

Görüntüle SekilEleman

o
+ataXY()
+ciz()
Sekil 1 n

i.c
<<factory>>

+yaratNokta()
+yaratDogru()

Nokta Dogru
-x: int
-y: int
dil
-n1: Nokta
-n2: Nokta

SekilDuzenleme örne i için UML gösterimi

AOP olu mas ndaki ana neden, geleneksel programlamlama dillerinde kimi sorunlar n (concerns)
va
kolayl kla ele al namay ya da modüle edilememisidir. Örne in bir program içerisinde ele al nmas
gereken güvenlik k s tlar n dü ündü ümüzde, zamanla bu k s tlar n de i ebilece i, geni letilebilece i ya
da program n farkl kesimlerinde de kullan m ihtiyac do uraca görülebilir. Fakat, güvenlik k s tlar n
nesneye yönelik programlama dilleri gibi geleneksel programlama dillerinde birim modüller (nesneye
yönelik programlamada sDnDf) haline getirmenin mümkün olmamas nedeniyle program n ihtiyaç duyulan
her yerinde bu k s tlar n tan mlanmas gerekir. Bu nedenle güvenlik, loglama gibi durumlar n geleneksel
programlama dillerinde kontrolü oldukça zor olmakla birlikte hataya da fazlas yla aç kt r.
ja

Güvenlik gibi sorunlar n nesneye yönelik programlamada sDnDflar gibi modüle edilememesinin ba l ca
nedeni sistematik bir ekilde tan mlanamamalar ile program boyunca yay lm olmalar ve de di er
s n flar enine kesmeleridir (cross-cut). Bu yüzden sDnDflar gibi tekrar kullan lamazlar(resuable) ve
kal t lamazlar(inheritance). K sacas , bu tür sorunlar n geleneksel programlama dillerince ele al nmalar
programlar için oldukça büyük bir yüktür.
w.

AOP, nesneye yönelik programlaman n genel sorunlar modüle etti i yönteme(sDnDflar) benzer bir ekilde
ilgileri (cross-cutting concerns) modüle etmeye olanak veren bir programlama mant d r. AspectJ de AOP
mant n gerçekle tiren bir JAVA gerçekle tirimidir.

AspectJ’nin javaya katt tek kavram birle me noktas (join point) kavram d r. Bunun d nda birle im
nokta kümeleri(pointcuts), tavsiyeyordam(advice), dahili-tür tan mlar (inter-type declarations) ve
ilgi(aspect) gibi yap lar da JAVA ya dahil etmi tir. Birle im nokta kümeleri ve tavsiyeyordamlar program
ww

i leyi ini dinamik olarak etkilerken dahili-tür tan mlar statik olarak s n f hiyerar isine etkide bulunurlar.
lgiler ise bu yap lar sarmalamak (encapsulate) maksad yla kullan l rlar.

Bir birleEme noktasD program ak boyunca iyi tan mlanm (well-defined) bir noktad r. BirleEim nokta
kümesi ise birle im noktalar ndan seçmeler yaparak olu turulmu bir kümeyi ifade eder. Tavsiyeyordam,
herhangi bir birle me noktas na gelindi inde çal t r lan kod parçac d r. Bunlar AspectJ nin dinamik
kesimlerini olu turur.

7
 Ayr ca AspectJ, program n statik yap s üzerinde(daha çok s n flara ait de i kenler ve yordamlar ile s n flar

m
aras ili kiler konu edilir) de i iklik yapabilecek birçok farkl dahili-tür tan m içerir.

AspectJ’de ilgiler ise JAVA’daki s n f tan mlar gibi AspectJ için birim modüller olarak dü ünülür. Bu
modüller ilgilerin(cross-cutting concerns) modüle edilmesi maksad yla yarat lm lard r, fakat s n flardan
farkl olarak birle me noktalar , birle im nokta kümeleri ve dahili-tür tan mlar da içerebilirler.

o
Birazdan anlataca m kesimde ilkin birle me noktalar na ard ndan bu noktalardan bir ya da birkaç n n
biraraya gelerek olu turdu u birle im nokta kümelerine, bu nokta kümelerine rastland durumlarda
çal t r lan kod parçac klar olan tavsiyeyordamlara göz ataca z. Daha sonra birle im nokta kümeleriyle
tavsiyeyordamlar n ilgi olu turmak üzere nas l bir araya geldi ini inceleyece iz. En son olarak da

i.c
tan mlar n program n statik yap s içinde yer alan s n flar içindeki ilgileri (cross-cutting concerns) ele
ald na de inece iz.

Dinamik BirleEme Noktasi Modeli(Dynamic Join Point Model)

Birle me noktas modeli (JPM), AOP deki kritik elemanlardan biridir. JPM, crosscutting sorunlar n
dinamik yap s n n tan mlanmas n mümkün k lan bir referans çerçeve sa lar. Bu k s mda, bir program

Yordam ça r ld nda
Yordam çal rken
Yap mc tetiklendi inde
Yap mc çal rken
dil
çal mas esnas nda belirgin olarak tan mlanm dinamik birle me noktalar ndan bahsedilecektir.
AspectJ’de kullan labilecek birle me noktalar :

Aspect kodu çal rken

Nesne yap land r l rken
va
S n f de i kenine eri ilirken
S n f de i kenine atama yap l rken

AspectJ, birçok birle me noktas tan m içerirken burada sadece yordam-ça r ml birle me noktas (method
call join point) üzerinde durulacakt r. Yordam-ça r ml birle me noktas , herhangi bir yordam taraf ndan
ça r lm bir nesnenin hareketlerini oldu u gibi sarmalar. Bu hareketlere, bir yordam ça r m na ait
argümanlar n al n p yordamdan dönü yap lana dek sahip oldu u tüm hareketler dahildir.
ja

Çal ma zaman ndaki tüm yordam ça r mlar n n her biri, ayn yordama ait ça r m olsa bile ayr bir birle im
noktas olarak ele al n r. Bir yordam ça r ml birle me noktas çal rken, o s rada birden fazla birle me
noktas ( yordam içerisinde olu mu ya da yordam gövdesinde ba ka bir yordam-ça r m sayesinde
meydana gelmi ) çal yor olabilir. Bu durumda, arka planda çal an birle me noktalar na orjinal yordam-
ça r ml birle me noktas n n dinamik ba lam n(dynamic context) da çal yor denir.
w.

BirleEim Nokta Kümeleri ( Pointcuts )

AspectJ’de birle im nokta kümeleri, program ak boyunca belli birle me noktalar n n seçilmesi yoluyla
olu turulmu kümelerdir. Örne in ;

call(void Nokta.ataX(int))
ww

yukaridaki birle im nokta kümesi, void Nokta.ataX(int) prototipinde( Nokta s n f na ait ataX (int) yordam )
olan tüm yordam-ça r m birle me noktalar n seçer.

Bir birle im nokta kümesi, ba ka birle im nokta kümelerinin ve( & ), veya( || ), de.il ( ! ) durumlar yla
ba lanmas yoluyla da olu turulabilir. Örne in ;

call(void Nokta.ataX(int)) ||

8
 call(void Nokta.ataY(int))

m
yukar daki örnekte, Nokta.ataX(int) veya Nokta.ataY(int))ye olan her bir yordam-ça r ml birle me
noktas seçilir.

Birle im nokta kümeleri, farkl türdeki birle me noktalar n da tan yabilirler. Örne in;

o
call(void SekilEleman.ataXY(int,int)) ||
call(void Nokta.ataX(int)) ||

i.c
call(void Nokta.ataY(int)) ||
call(void Dogru.ataN1(Nokta)) ||
call(void Dogru.ataN2(Nokta));

yukar daki kod kesimi ile 5 yordam ça r m ndan herhangi birine yap lan ça r m olan birle me noktalar n n
her biri seçilir. Tan mlad m z örnek sisteme göre yukar daki kod kesimi ile bir SekilElement hareketi
gerçekle ti inde tüm birle me noktalar n yakalan r (capture). Bu crosscutting sorunlar n tespiti aç s ndan
güzel bir yol olmas na ra men kullan m ve kontrolü zordur. Bu durumu a mak için AspectJ,

call(void
call(void
dil
programc lar n birle im nokta kümelerine istedikleri ismi vermelerine imkan tan r. Örne in a a daki kod
ile isimlendirilmi bir birle im nokta kümesi olu turulur :

pointcut tasi() :
SekilEleman.ataXY(int,int))
Nokta.ataX(int))
||
||
call(void Nokta.ataY(int)) ||
call(void Dogru.ataN1(Nokta)) ||
va
call(void Dogru.ataN2(Nokta));

Bu tan m n görünür (visible) oldu u bir an programc n n bahsedilen karma k birle im kümesini yakalamak
için tasi() kullanmas yeterlidir.

Yukar daki tüm örneklerde, yordamlara ait tam yap verilerek birle im nokta kümelerinin olu umu
sa lanm t r. Bu yöntem isim-bazl enine kesim (name-based crosscutting) olarak da bilinir. AspectJ
programc lara, yordam n tam bir prototipini belirtmeleri yerine sadece yordama ili kin belli bir özelli i
ja

belli birtak m özel simgeler(wildcards) kullanarak ifade etmelerine olanak verir. Buna özellik-bazl enine
kesim (property-based crosscutting) de denir. Örne in, birle im nokta kümesi

call(void Sekil.yarat*(..))

Sekil s n f na ait void geri dönü tipine sahip ad yarat ile ba layan, ald parametrelerden ba ms z tüm
w.

yordam ça r mlar n seçer. Bu tan m ile, örnek sistemimiz içindeki yaratNokta ve yaratDogru factory
yordamlar seçilir. Birle im nokta kümesi

call(public * Sekil.* (..))

Sekil s n f n n public türde olan her bir yordam na yap lan yordam ça r mlar n seçer.
ww

AspectJ de kullan labilecek tek özellik (property) özel simgeler (wildcards) de ildir. Di er bir birle im
nokta kümesi, cflow, di er birle me noktalar n n dinamik ba lam nda (dynamic context) ortaya ç kan
birle me noktalar n belirtir. Bu sayede,

cflow(tasi())

9
 tasi() ile seçilen birle me noktalar n n dinamik ba lam nda ortaya ç kan birle me noktalar n seçer. Yani,

m
bu birle im nokta kümesi, tasi yordam n n ça r lmas ndan bitimine kadar ki süreçte ortaya ç kan her bir
birle me noktas n seçer.

Tavsiyeyordam ( Advice )

o
Yukar da belirtildi i üzere birle im nokta kümeleri, bir dizi birle me noktas n seçmek için kullan l r ama
bu noktalar üzerinde ne gibi i lemler yap laca na ya da bu noktalar n ne ekilde kullan laca na dair bir
bilgi içermezler. AspectJ’de bu görev tavsiyeyordam (advice)’lara verilmi tir.

i.c
AspectJ’de bir çok tavsiyeyordam yer al r. Bunlardan before, bir birle me noktas n n i letimine geçilmeden
önce ele al nmas istenen durumlar n tan mland tavsiyeyordam’d r. Örne in, bir yordam-ça r ml
birle me noktas üzerinde tan ml tavsiyeyordam gerçek yordam i letime al nmadan hemen önce (gerçek
yordama ait parametre geçi inin hemen ard ndan) i letilir.

before() : tasi() {
System.out.println(“ta nmadan hemen önce”);
}

dil
After tavsiyeyordam ise program n, birle me noktas n i letmesinin hemen ard ndan i letilir. Örne in, bir
yordam-ça r ml birle me noktas yla tan mlanm bir tavsiyeyordam, yordam n i letiminin ard ndan
kontrol ça ran yordama geçmeden hemen önce i letilir. Java programlar bir birle me noktas ndan normal
olarak ya da ayk r durum f rlatarak ç kabileceklerinden AspectJ’de üç tip after tavsiyeyordam bulunur.
Bunlar : after returning, after throwing, after(normal sonlanma ya da ayk r durum olu umundan
herhangi birinden sonra).
va
after () returning : tasi () {
System.out.println(« ba ar l bir ta man n ard ndan ») ;
}

BirleEim Nokta Kümelerinde çerik Gösterimi (Context Exposing)

Birle im nokta kümeleri, birle me noktalar n seçmek d nda birle me noktalar ndaki i letim içeri ini
(execution context) de gösterebilirler. Birle im nokta kümeleri taraf ndan ortaya ç kar lan (gösterilen)
ja

de erler, tavsiyeyordam tan mlar nda kullan labilirler.

Bir tavsiyeyordam tan m , Java’daki yordamlarda oldu u gibi bir parametre listesine sahiptir. Bu
parametreler, tavsiyeyordam taraf ndan kullan lacak içerik parçalar na isim vererek gövde k sm nda
kullan labilecek ekilde tan mlanm t r. Örne in a a daki ;
w.

after (SekilEleman se, int x, int y) returning :

…BaziBirlesimNoktaKumeleri…{
…BaziGövdeTanimlari…
}

tavsiyeyordam, se ad nda bir SekilEleman ile x ve y ad nda iki int türünde parametre olmak üzere toplam
üç parça exposed context içerir.
ww

Tavsiyeyordam gövdesi, aynen Java’daki yordamlarda oldu u gibi parametre kullan m na sahip oldu u
için tavsiye yordam a a daki ekli alabilir :

after (SekilEleman se, int x, int y) returning :

…BaziBirlesimNoktaKumeleri…{
System.out.println(se + « belirtilen noktalara ta nd (« + x
+ », « + y + ») ») ;
}

10
 Tavsiyeyordama ait birle im nokta kümesi, argümanlara ait de erleri ne retmek (göstermek - publish) için

m
kullan l r. Üç ilkel birle im nokta kümesi bu argümanlara ait de erleri göstermek için kullan labilir : this,
target, args. Bu durumda tavsiyeyordam n alaca ekil a a daki gibi olacakt r.

after (SekilEleman se, int x, int y) returning :

call(void SekilEleman.ataXY(int, int))
&& target(se)

o
&& args(x,y){
System.out.println(se + « belirtilen noktalara ta nd (« + x
+ », « + y + ») ») ;
}

i.c
Tavsiyeyordam ataXY yordam ndan üç de er ç kar r : hedef SekilEleman (se) ve iki int de er x, y.
Bunlardan se after tavsiyeyordam n n ilk argüman olurken x ile y son iki arguman olur. Bu durumda,
yukar daki tavsiyeyordam, her ataXY yordam n n i letiminin ard ndan SekilEleman se ve yeni x, y
koordinatlar n ekrana basar.

Bir isimlendirilmi birle im nokta kümesi, tavsiyeyordam parças gibi bir parametre listesine sahip olabilir.
Yukar daki tavsiyeyordam bu durumda a a da gösterildi i gibi de yaz labilir :

dil
Pointcut ataXY(SekilEleman se, int x, int y):
call(void SekilEleman.ataXY(int, int))
&& target(se)
&& args(x,y) ;

after (SekilEleman se, int x, int y) returning : ataXY(se,x,y) {

System.out.println(se + « belirtilen noktalara ta nd (« + x
va
+ », « + y + ») ») ;
}

Dahili-tür TanDmlarD

Dahili tür tan mlar , s n flar ve s n f hiyerar ilerini enine kesen tan mlard r. Birden fazla s n f enine kesen
s n f özelli i tan mlayabilir ya da s n flar aras kal t m ili kisi üzerinde de i iklik yapabilir. Tavsiye-
metodlardan farkl olarak dinamik de il de statik olarak i lev görürler.
ja

Haz r bir s n f hiyerar isine sahip bir programa, birçok s n f taraf ndan payla lacak yeni bir yetenek
(capability) eklememiz gerekti ini dü ünelim. (Örne in, bu s n flar bir ata s n ftan türetilmi olsunlar) Bu
durumda Java bir Interface (=Arayüz) tan mlay p bu yetene e ait yordam ya da yordamlar bu arayüzün
içine gömme yoluyla geni lemeyi sa lar. Böylece bu yeni yetene e sahip olacak s n flar bu arayüzü
implement edecek yordamlarla geni letilirler.
w.

AspectJ, bu sorunu sadece tek bir yap olu turarak, varolan s n flar üzerinde herhangi bir de i ikli e
gitmeden, halledebilir. Yeni yetene in eklenebilmesi için gereken yordam ve alanlar tan mlay p bunlar
varolan s n flar ile ili kilendirir.

Daha önceden varolan bir s n f olan Nokta s n f na ait nesneleri üzerindeki de i imleri gözlemek üzere
gözlemci rolüne sahip Ekran nesnelerine sahip olmak istedi imizi varsayal m. Nokta nesneleri üzerindeki
ww

de i imleri gözleyen Ekran nesnelerinin izini tutan gozlemciler ad nda Nesne s n f na ait bir alan aspect
(ilgi) yazarak kodlayabiliriz.

aspect NoktaGozlem {
private Vector Nokta.gozlemciler = new Vector() ;
………
}

11
 gozlemciler alan private oldu undan sadece NoktaGozlem’den eri ilebilir. Bu nedenle, gözlemciler ancak

m
static yordamlar gozlemciEkle, gozlemciCikar yordamlar n n aspect (ilgi)’e eklenmesi yoluyla eklenip
ç kar labilirler.

aspect NoktaGozlem {
private Vector Nokta.gozlemciler = new Vector() ;
public static void gozlemciEkle ( Nokta n, Ekran e) {

o
n.gozlemciler.add(e) ;
}
Public static void gozlemciCikar ( Nokta n, Ekran e) {
n.gozlemciler.remove(e) ;
}

i.c
………
}

Bunlar n ard ndan, neyi izlemek istedi imize dair degisiklikler ad nda bir birle im nokta kümesi
tan mlayabiliriz. after tavsiye-yordam ise bir de i iklik meydana geldi inde ne yapaca m z tan mlamak
için kullan labilir.

aspect NoktaGozlem {
dil
private Vector Nokta.gozlemciler = new Vector() ;
public static void gozlemciEkle ( Nokta n, Ekran e) {

}
n.gozlemciler.add(e) ;

Public static void gozlemciCikar ( Nokta n, Ekran e) {

n.gozlemciler.remove(e) ;
}
va
pointcut degisiklikler(Nokta n) : target(n) &&
call(void Nokta.ata*.(int)) ;

after(Nokta n) : degisiklikler(n) {
Iterator iter = n.gozlemciler.iterator() ;
While(iter.hasNext()) {
gozlemciGoruntule(n, (Ekran) iter.next()) ;
ja

}
static void gozlemciGoruntule(Nokta n, Ekran e) {
e.goruntule(n) ;
}
}
w.

Görüldü ü üzere, bu yeni yetene in programa kat lmas esnas nda ne Nokta s n f ne de Ekran s n f
kodlar nda herhangi bir de i ikli e gerek duyulmad .

Aspects ( lgiler)

=lgiler, birle me noktalar, birle im nokta kümeleri ve dahili-tür tan mlar n bir modül olarak sarmalayan,
Java’daki s n f vari bir yap d r. S n flar gibi yordamlar, alanlar ve ilk de er atay c lar (initializers) içerebilir.
Aspect’lere de s n flar gibi ilk de er atanabilir fakat bunun nas l yap laca kontrol alt ndad r ve bu nedenle
ww

Java’n n new format ile aspect nesneleri (instance) yarat lamaz. Her bir aspect asl nda bir Singleton’dur ve
sadece bir nesne yarat l r. Bu nedenle tavsiye-yordam aspect’in non-static alanlar n kullanabilir.

12
 aspect Loglama {

m
OutputStream logStream = System.err ;

before() : tasi() {
logStream.println(« ta nmak üzere ») ;
}
}

o
GELISTIRME PLATFORMU (UYGULAMALI TANITIM)
Aspectj günümüzde Eclipse projelerinden biri olarak geli tirilmeye devam etti inden geli tirme platformu
olarak Eclipse anlat lacakt r. Eclipse üzerinde uygulama geli tirmek için öncelikle

i.c
http://www.eclipse.org/aspectj/ adresinden aspectj-xxx.jar çal t r labilir kütü ü indirilerek çal t r lmal d r.
Bu dosya çal t r labilir bir GUI arayüzüne sahip oldu undan yüklemesi oldukça kolayd r. Program
kurulumuna ait bir ekran görüntüsü a a dad r.

dil
ja va
w.

Kurulumun tamamlanmas n n ard ndan, kurulum dizini/lib (Örne in ; C:\aspectj1.2\lib)’in alt nda yer alan
aspectjrt.jar kütü ü classpath’e eklenmelidir. Bu kütük yaz lan s n f ve aspect’lerin ajc derleyicisi
taraf ndan derlenmesi ve ajc taraf ndan derlenmi kütüklerin çal t r lmas için gerekli olan s n flar içerir.
aspectjrt.jar kütü ünü classpath’e eklemek için kullan labilecek yollardan en uygunu bu kütü ü
jdk/jre/lib/ext dizininin alt na kopyalamakt r.
ww

Kurulum ve program geli tirimine ait dökümantasyona (i.e.api, userguide) yine AspectJ kurulum dizini
alt nda yer alan /doc dizini arac l yla eri ilebilir.

Ayr ca, kurulum dizini alt nda birçok örnek uygulama program da yer ald ndan bunlar n incelenmesi
arac l yla program geli tirimi kolayla t r labilir.

13
 Yukar da belirtilen i lemlerin tamanlanmas n n ard ndan Eclipse’de kod yaz l p çal t r labilecektir. Bu

m
anlamda örnek bir uygulama (Aspect (ilgi) kullan larak yordam takibi) ileride ekran görüntüleriyle
desteklenerek anlat lacakt r.

lgi KullanDlarak Yordam Takibi

Takip (tracing) özelli ine sahip bir s n f yazmak oldukça kolayd r : birkaç fonksiyon, izlemeyi aç p

o
kapatacak bir boolean i aret, output stream için bir seçenek ve belki de output format n ayarlamak için
program n öngördü ü bir kod kesimi. Bunlar takip s n flar n n sahip olmas gereken temel özelliklerdir.
Yaln z program gereksinimleri göz önüne al nd nda, takip oldukça karma k bir yap ya da bürünebilir.

i.c
Asl nda takip geli tirimi i in kolay yan n olu turur. Takip s n flar için as l problem yaratan kesim program
içinden uygun zamanlarda takip için etkile ime geçmektir. Bu maksatla yap lan yordam ça r mlar özellikle
büyük sistemlerde oldukça bunalt c olabilmekle beraber sisteme a r yük olarak da negatif etki yapar ve
çal ma h z n dü ürür. Bu nedenle, program sat a amas na geldi inde takip s n flar n n sistemden
ç kar lma durumu olu ur. Bu durum göz önüne al nd nda program geli tiren ki ilerin, yordam gövdeleri
i letilmeden önce ve i letildikten sonra takip ekleme ç karma yoluyla yordam ça r mlar yapan geçici (ad-
hoc) scripting programlar kullanmalar oldukça do ald r.

dil
AspectJ, bahsedilen geçici scripting kullan mlar n n önüne geçecek ya da kullan mlar n azaltacak bir i lev
sa lar. Takip tüm bir sistemi etkiledi i göz önüne al n rsa, sistem için bir cross-cutting concern olarak
görülebilir, bu durumda bir aspect (ilgi) taraf ndan sarmalanarak sisteme dahil edilmesi olas d r.

Örnek Uygulama :

Örnek uygulama olarak ilk a amada 4 s n ftan olu an basit bir 'ekil uygulamas verilecektir. Bu uygulama
ata s n f olarak Sekil, bu s n ftan türeyen Kare ve Daire s n flar ile bu s n flara ait yordamlar n kullan ld
va
main yordam na sahip OrnekMain s n f n içerecektir.

Bu uygulaman n Eclipse platformu üzerinde geli tirimi ve çal t r lmas ad m ad m verilecektir. Öncelikle
Takip adl bir AspectJ projesi açmakla i e ba l yoruz. Bunun için, File new Project yoluyla aç lan
pencereden AspecjJ Project seçilir. Aç lan pencereye ait ekran görüntüsü a a daki gibidir.
ja
w.
ww

14
 o m
i.c
dil
ja va

Project name alan doldurularak projeye bir isim verilir (örne imiz için proje ad Takip olacakt r) ve
Finish’e bas larak proje olu turulur. Package Explorer’da Takip ba l alt nda proje görüntülenebilir.
Takip projesi içinde takip ad nda bir package yarat l r. Bu i lem için File new Package yolu
izlenebilir.
w.
ww

15
 Bu i lemin ard ndan aç lacak pencere görünümü a a da verilmi tir.

o m
i.c
dil
va
Name alan na takip yaz ld ktan sonra Finish dü mesine bas larak Takip projesi içinde takip ad nda bir
package olu turulur.

Sekil ad ndaki ata s n f olu turmak için File new class seçene i kullan l r. S n flar ayn yöntemle
yarat lacaklar için ekran görünümü sadece bu s n fta verilecektir.
ja
w.
ww

16
 o m
i.c
dil
ja va

Package alan na takip, Name alan na Sekil yaz ld ktan sonra Finish dü mesine bas larak Sekil s n f
yarat larak takip paketine eklenir. Sekil s n f n n yarat lmas n n ard ndan Eclipse’e ait ekran görüntüsü
a a daki gibi olacakt r.
w.
ww

17
 o m
i.c
dil
va
Sekil s n f na ait kod kesimi a a dad r :

package takip;

/**
* Sekil s n f bir abstrack s n f olup, 2 boyutlu ekillere ait genel
fonksiyonlar içerir
ja

*/
public abstract class Sekil {
/**
* "eklin merkezine ait x ve y koordinatlar
*/
protected double x, y;
w.

protected Sekil(double x, double y) {

this.x = x; this.y = y;
}

/**
* x koordinat n döner
ww

*/
public double getX() { return x; }

/**
* y koordinat n döner
*/
public double getY() { return y; }

18
 /**

m
* Parametre olarak gelen ekille bu ekil aras ndaki mesafeyi
döner
*/
public double distance(Sekil s) {
double dx = Math.abs(s.getX() - x);
double dy = Math.abs(s.getY() - y);

o
return Math.sqrt(dx*dx + dy*dy);
}

/**
* "eklin çevresini döner. Alt s n flarda tan mlanmak zorundad r.

i.c
*/
public abstract double cevre();

/**
* "eklin alan n döner. Alt s n flarda tan mlanmak zorundad r.
*/
public abstract double alan();

/**

koordinatlar n
*/
public String toString() {
dil
* eklin string gösterimini döner -- basitçe x ve y

return (" @ (" + String.valueOf(x) + ", " +

String.valueOf(y) + ") ");
}
va
}

Sekil s n f n n alt s n flar olan Kare ve Daire s n flar da ayn ekilde projeye dahil edilir. Projenin
çal t r labilmesi için gerekli bir main () yordam içeren OrnekMain s n f n n da eklenmesiyle çal t r labilir
bir Java application haz rlanm olur. Bu s n flara ait kod kesimleri a a da yer almaktad r.

Kare s n f na ait kod kesimi :

ja

package takip;

/**
*
* Kare, Sekil s n f n kenar özelliTiyle implement eder. cevre ve alan
w.

yordamlar n karenin
* çevre ve alan n doTru ekilde hesaplayacak ekilde kodlar.
*
*/
public class Kare extends Sekil {
protected double k; // kenar

/*
ww

* Her türden constructor

*/
public Kare(double x, double y, double k) {
super(x, y); this.k = k;
}

public Kare(double x, double y) {

this(x, y, 1.0);

19
 }

m
public Kare(double k) {
this(0.0, 0.0, k);
}

public Kare() {

o
this(0.0, 0.0, 1.0);
}

/**
* Karenin çevresini döner

i.c
*/
public double cevre() {
return 4 * k;
}

/**
* Karenin alan n döner

/**
*/
public double alan() {
return k*k; dil
* Bu yordam ata s n ftaki toString yordam n override eder.
* Kare ile ilgili spesifik bilgi içerir.
*/
va
public String toString() {
return ("Karenin kenar = " + String.valueOf(k) +
super.toString());
}
}

Daire s n f na ait kod kesimi :

ja

package takip;

/**
*
* Daire, Sekil s n f n yar çap özelliTiyle implement eder. cevre ve
w.

alan yordamlar n karenin

* çevre ve alan n doTru ekilde hesaplayacak ekilde kodlar.
*
*/
public class Daire extends Sekil {
protected double r; // yar çap --> radius

/*
ww

* Yap c lar
*/
public Daire(double x, double y, double r) {
super(x, y); this.r = r;
}

public Daire(double x, double y) {

this(x, y, 1.0);

20
 }

m
public Daire(double r) {
this(0.0, 0.0, r);
}

public Daire() {

o
this(0.0, 0.0, 1.0);
}

/**
* Dairenin çevresini döner

i.c
*/
public double cevre() {
return 2 * Math.PI * r;
}

/**
* Dairenin alan n döner

}
*/
public double alan() {

/**
return Math.PI * r*r; dil
* Bu yordam ata s n ftaki toString yordam n override eder.
* Daire ile ilgili spesifik bilgi içerir.
*/
va
public String toString() {
return ("Daire yar çap = " + String.valueOf(r) +
super.toString());
}
}

OrnekMain s n f na ait kod kesimi :

ja

package takip;

/**
*
* "ekilleri test etmek için gereken main() yordam n içeren s n f
w.

*
*/
public class OrnekMain {
public static void main(String[] args) {
Daire d1 = new Daire(3.0, 3.0, 2.0);
Daire d2 = new Daire(4.0);

Kare k1 = new Kare(1.0, 2.0);

ww

System.out.println("d1.cevre() = " + d1.cevre());

System.out.println("d1.alan() = " + d1.alan());

System.out.println("k1.cevre() = " + k1.cevre());

System.out.println("k1.alan() = " + k1.alan());

System.out.println("d2.mesafe(d1) = " + d2.mesafe(d1));

21
 System.out.println("k1.mesafe(d1) = " + k1.mesafe(d1));

m
System.out.println("k1.toString(): " + k1.toString());
}
}

Tan mlanan s n flara ait yordamlar n do ru çal p çal mad n görmek maksad yla OrnekMain s n f

o
çal t r l r. Projeyi çal t rmak için Run Run as aspectJ/Java application yolu izlenir ve
a a daki ç kt elde edilir.

d1.cevre() = 12.566370614359172

i.c
d1.alan() = 12.566370614359172
k1.cevre() = 4.0
k1.alan() = 1.0
d2.mesafe(d1) = 4.242640687119285
k1.mesafe(d1) = 2.23606797749979
k1.toString(): Karenin kenar = 1.0 @ (1.0, 2.0)

Yukar da tan m verilen uygulamaya aspect kullanmadan takip mekanizmas eklemek istedi imizde a a da

AspectsizTakip s n f na ait kod kesimi :

package takip;
dil
kod kesimi verilen AspectsizTakip s n f na benzer yap da bir s n f eklememiz gerekir.

import java.io.PrintStream;
va
/**
*
* Bu s n f baz temel takip i levlerine ait mesajlar yazmay saTlar.
*
*/
public class AspectsizTakip {
/**
* 3 takip seviyesi bulunur (TAKIPSEVIYESI deTerleri):
ja

* 0 - Hiçbir mesaj yaz lmaz

* 1 - Takip mesajlar yaz l r, fakat girintili yaz m yoktur
* 2 - Trace messages are printed, fakat girintili yaz m vard r
*/
public static int TAKIPSEVIYESI = 0;
protected static PrintStream stream = null;
w.

protected static int cagirmaDerinligi = 0;

/**
* !lk deTer atama.
*/
public static void initStream(PrintStream s) {
stream = s;
}
ww

/**
* "giriyor" eklinde bir mesaj yazar. Takip edilmek istenen
yordam n ba nda
* çaTr lmas niyetlenmi tir.
*/
public static void takipGiris(String str) {

22
 if (TAKIPSEVIYESI == 0) return;

m
if (TAKIPSEVIYESI == 2) cagirmaDerinligi++;
girisYazdir(str);
}

/**
* "ç k yor" eklinde bir mesaj yazar. Takip edilmek istenen

o
yordam n sonunda
* çaTr lmas niyetlenmi tir.
*/
public static void takipCikis(String str) {
if (TAKIPSEVIYESI == 0) return;

i.c
cikisYazdir(str);
if (TAKIPSEVIYESI == 2) cagirmaDerinligi--;
}

private static void girisYazdir(String str) {

girintiBirak();
stream.println("--> " + str);
}

}
girintiBirak();
stream.println("<-- " + str);
dil
private static void cikisYazdir(String str) {

private static void girintiBirak() {

for (int i = 0; i < cagirmaDerinligi; i++)
va
stream.print(" ");
}
}

E er aspect olmasayd yukar daki s n fla çal mak zorunda kal nacakt . Bu durumda takip edilmek istenen
tüm yordam ve yap c lar n ba nda girisYazdir(), sonunda da cikisYazdir() yordamlar n ça rmak ve
TAKIPSEVIYESI ile stream’e ilk de er atamalar n yapmak gerekecekti. Ayr ca arada baz yordamlar
atlama ihtimali de bulunaca ndan oldukça sa l ks z bir yöntem oldu u aç kt r. Bu nedenle takip
ja

mekanizmas n aspect kullanarak kodlamak çok daha mant kl d r. Bu i levi yerine getirebilecek bir aspect’e
ait kod a a dad r :

AspectliTakip aspect’ine ait kod kesimi :

w.

package takip;

/**
* Bu s n f AspectsizTakip s n f ndaki takip yordamlar ile uygulama
s n flar ndaki
* yap c ve yordamlar birbirine baTlar.
*
*/
ww

aspect AspectliTakip {
/**
* Uygulama s n flar .
*/
pointcut benimSinifim(): within(Sekil) || within(Daire) ||
within(Kare);
/**
* Bu s n flardaki yap c lar.

23
 */

m
pointcut benimYapicim(): benimSinifim() && execution(new(..));
/**
* Bu s n flardaki yordamlar.
*/
pointcut benimYordamim(): benimSinifim() && execution(* *(..));

o
/**
* Yap c lar çal madan önce ve çal t ktan sonra takip mesajlar
yazar.
*/
before (): benimYapicim() {

i.c
AspectsizTakip.takipGiris("" +
thisJoinPointStaticPart.getSignature());
}
after(): benimYapicim() {
AspectsizTakip.takipCikis("" +
thisJoinPointStaticPart.getSignature());
}

/**

mesajlar yazar.
*/
before (): benimYordamim() {
dil
* Yordam gövdeleri çal madan önce ve çal t ktan sonra takip

AspectsizTakip.takipGiris("" +
thisJoinPointStaticPart.getSignature());
}
va
after(): benimYordamim() {
AspectsizTakip.takipCikis("" +
thisJoinPointStaticPart.getSignature());
}

/**
* AspectsizTakip aspect'inin çal mas için gereken main
fonksiyon.
ja

*/
public static void main(String[] args) {
AspectsizTakip.TAKIPSEVIYESI = 2;
AspectsizTakip.initStream(System.err);
OrnekMain.main(args);
w.

}
}

Yukaridaki aspect, yordam ça r mlar nda uygun takip mekanizmalar n i letir. Dolay s yla verilen s n f
hiyerar isinde ça r lan her yordam ve yap c için yordama giri te ve yordamdan ç k ta giri ya da ç k
mesajlar yazd r r.

Yordam giri inde ya da ç k nda yazd r lan mesaj çal an yordama ait signature (imza) d r. =mza statik bir
ww

bilgi oldu u için thisJoinPointStaticPart ile eri ilebilir.

AspectliTakip aspect’i içinde yer alan main() yordam kullan larak bu uygulama çal t r l r. Uygulamay
çal t rmak için AspectliTakip aspect’i aktif iken Run Run as aspectJ/Java application seçilir.
Çal ma sonucu elde edilen ç kt a a dad r.

24
 --> takip.Sekil(double, double)

m
<-- takip.Sekil(double, double)
--> takip.Daire(double, double, double)
d1.cevre() = 12.566370614359172
d1.alan() = 12.566370614359172
k1.cevre() = 4.0
k1.alan() = 1.0

o
d2.mesafe(d1) = 4.242640687119285
<-- takip.Daire(double, double, double)
--> takip.Sekil(double, double)
<-- takip.Sekil(double, double)
--> takip.Daire(double, double, double)

i.c
<-- takip.Daire(double, double, double)
--> takip.Daire(double)
<-- takip.Daire(double)
--> takip.Sekil(double, double)
<-- takip.Sekil(double, double)
--> takip.Kare(double, double, double)
<-- takip.Kare(double, double, double)

dil
--> takip.Kare(double, double)
<-- takip.Kare(double, double)
--> double takip.Daire.cevre()
<-- double takip.Daire.cevre()k1.mesafe(d1) = 2.23606797749979
k1.toString(): Karenin kenar = 1.0 @ (1.0, 2.0)

--> double takip.Daire.alan()

<-- double takip.Daire.alan()
--> double takip.Kare.cevre()
va
<-- double takip.Kare.cevre()
--> double takip.Kare.alan()
<-- double takip.Kare.alan()
--> double takip.Sekil.mesafe(Sekil)
--> double takip.Sekil.getX()
<-- double takip.Sekil.getX()
--> double takip.Sekil.getY()
<-- double takip.Sekil.getY()
ja

<-- double takip.Sekil.mesafe(Sekil)

--> double takip.Sekil.mesafe(Sekil)
--> double takip.Sekil.getX()
<-- double takip.Sekil.getX()
--> double takip.Sekil.getY()
w.

<-- double takip.Sekil.getY()

<-- double takip.Sekil.mesafe(Sekil)
--> String takip.Kare.toString()
--> String takip.Sekil.toString()
<-- String takip.Sekil.toString()
<-- String takip.Kare.toString()
ww

25
 = letim sonunda elde edilen ekran görüntüsü a a dad r :

o m
i.c
dil
va
AOP VE D 7ER PROGRAMLAMA MODELLER

AOP, nesneye yönelik programlama (OOP)’n n eksiklerinin göz önüne al nmas yla olu turulmu tur ve
meta-object protocols’e benzer bir fonksiyona sahiptir. Aspect (ilgi) subject, mixins ve delegation gibi
programlama konular yla yak ndan alakal d r.
ja

Matematiksel olarak, ilgiler herhangi bir programlama modeli için bir ikinci düzen formu olu tururlar.
Genel programlama modelleri basit fonksiyonlar ve mesajlarla ilgili muhakeme imkan verirken, AOP tüm
bunlar n kümesi üzerinde birle im nokta kümesi arac l yla muhakeme imkan verir. Bu nedenle, istendi i
taktirde AOP, ba ms z bir programlama modelinden ziyade güçlü bir gerçekle tirim (extension) olarak da
görülebilir.
w.

AOP PROBLEMLER

AOP’n n en büyük sorunlar ndan biri hata ay klama (debugging) dir. Bunun nedeni de program kodu
içersinde AOP kodunun ayr görünmesine ra men çal ma a amas nda bu ayr m n yok olmas d r. Bu
durumda çal ma s ras nda, ilgi dokuma (concern weaving), hangi ilginin bask n olaca belirtilmezse
tahmin edilemeyebilir. Tasar mc lar kodun ayr lmas konusunda her nekadar alternatif çözüm yollar da
ww

aram olsalar, bunlar n hiçbiri programc lar n birden fazla birle me noktas na bir tek tan mlay c cümlecik
ile eri melerini sa layamam t r.

Di er bir sorun ise AOP geli tirimlerinde istenmeyen birle me noktalar n n da özel i aretler (wildcards)
yoluyla birle im nokta kümelerine dahil edilmesidir. Diyelim ki, bir programc belli bir karakter kümesi
kullanarak bu karakter kümesiyle ba layan yordamlara ili kin birle me noktalar n bir birle im nokta
kümesinde toplam olsun. Belli bir süre sonra programa unutarak bu karakter kümesiyle ba layan ba ka bir
yordam ekledi inde bu yordama ait birle me noktas da önceki birle im nokta kümesine dahil olacakt r. Bu

26
 durumda programc yazd her birle im nokta kümesi üzerinde mutlak bir hakimiyete sahip olmal d r. Bu

m
da büyük programlar için oldukça zordur.

KAYNAKÇA

• http://aosd.net/conference

o
• http://aosd.net/wiki
• http://eclipse.org/aspectj/
• http://www.aspectbench.org/

i.c
• http://www.javaworld.com/javaworld/jw-01-2002/jw-0118-aspect.html
• http://www.codefez.com/Home/tabid/36/articleType/ArticleView/articleId/98/Asp
ectOrientedProgrammingwithTacobymarchoffman.aspx
• http://www.cis.uab.edu/gray/Research/C-SAW/

dil
ja va
w.
ww

27