1CORBA

Hacettepe Üniversitesi
Bilgisayar
Mühendisliği Bölümü
CORBA
(Common Object Request Broker
Architecture)
Hacettepe Üniversitesi Bilgisayar Mühendisliği
2006, Ankara
HAZIRLAYANLAR
Ekip İsim - Soyisim E-Posta Tarih

2. Ekip Doğukan DOĞAN dogukan_dogan@hotmail.co 01.12.2006
Yusuf KARTAL m
ykartal@gmail.com
1. Ekip Emre ÇAĞLAR 20.11.2005
Belgeye ilişkin eleştiri ve önerilerinizi lütfen Ar. Gör. Fatih M. GÜLEÇ’e bildirin. 2
fatihg@cs.hacettepe.edu.tr
İçindekiler
İçindekiler.........................................................................................................................................3
1-OMG..............................................................................................................................................4
2-CORBA Mimarisi..........................................................................................................................4
2.1 IDL......................................................................................................................................5
2.2 OMA...................................................................................................................................5
3-ORB...............................................................................................................................................6
4-Dağıtık nesnelerde standart olarak CORBA.................................................................................7
4.1 IIOP....................................................................................................................................7
4.2 Java RMI.............................................................................................................................8
5-CORBA Servisleri.........................................................................................................................9
6-CORBA Ürünleri.........................................................................................................................10
7-CORBA ile Örnekler...................................................................................................................10
7.1 Gereksinimler ve Kurulumlar...........................................................................................10
7.2 Hello World Uygulaması..................................................................................................12
7.3 Banka Uygulaması............................................................................................................22
8-Kaynaklar....................................................................................................................................31
1- OMG
OMG (Object Management Group) çeşitli bilgi sistemleri üreticileri, yazılım geliştiricileri ve kullanıcılarının
oluşturduğu, kar amacı gütmeyen uluslararası bir kuruluştur. OMG 1989 yılında kurulmuştur ve su anda
600’ü askın üyesi vardır. OMG, dağıtık, ölçeklenebilir, yeniden kullanılabilir, taşınabilir özelliklerde, yaygın
çapta açık bir uygulama çatısı sunar.
2- CORBA Mimarisi
CORBA (Common Object Request Broker Architecture), OMG’nin (Object Management Group) internet
üzerinden birlikte çalışan uygulamalar için tasarladığı alt yapıdır. CORBA Nesne Yönetim Grubu'nun
(OMG) Nesne Yönetim Mimarisi'nin (OMA) ana bileşenlerinden birisidir. Nesne Yönetim Mimarisi Nesne
Modeli ve Referans Modelinden oluşur. Nesne Modeli heterojen bir ortamda dağılmış nesnelerin nasıl
tanımlanabileceğini belirler. Referans Modeli ise nesneler arası etkileşimleri tanımlar. Dolayısıyla Nesne
Yönetim Mimarisi heterojen ortamlara dağılmış beraber isleyebilen dağıtık nesnelerin geliştirilmesine ve
konuşlandırılmasına yardımcı olur. Herhangi bir satıcının, herhangi bir işletim sistemi üzerinde çalışan,
herhangi bir dille yazılmış CORBA tabanlı bir uygulaması, IIOP protokolü üzerinden; başka herhangi bir
satıcının, herhangi bir işletim sistemi üzerinde çalışan, herhangi bir dille yazılmış bir başka CORBA tabanlı
uygulaması ile iş birliği içinde çalışabilir.
Dağıtık işlemler, bilgisayar alanında pek çok çözümde iyi bir yol sağlamaktadır. Paralel ve hızlı bir şekilde
işlem yapmaları; hataya karşı daha dirençli olmaları gibi sebepler de dağıtık işleyen yapılara yönelmeye
sebep olmuştur. Dağıtık işlemi sağlamak için kimi çözümler çıkmıştır. Bunlara soketler ve dağıtık işlem
yapmak için tasarlanmış dilleri örnek verebileceğimiz gibi, daha üst seviyede CORBA ve RPC gibi yapıları
da örnek verebiliriz. CORBA, RPC ile pek çok benzerliğe sahiptir. Yalnız RPC daha çok yapısal dillere
yönelik iken; CORBA temel olarak nesneye yönelik dillere göre tasarlanmıştır.
Dağıtık nesnelerin iki yönü vardır. Bunlar sunucu ve istemci yönüdür. En basit haliyle bu ilişki söyle
gerçekleşir: Sunucu uzak bir ara yüz (remote interface) sağlar ve istemci de sağlanan uzak ara yüzü
çağırır. Bu ilişki RMI ve CORBA gibi birçok dağıtık nesne standartlarında benimsenen bir yaklaşımdır. Bu
bağlamda, sunucu ve istemci terimlerinden kastedilen uygulama düzeyindeki etkileşimlerden ziyade nesne
düzeyindeki etkileşimlerdir. Yani bir uygulama, herhangi bir nesne için sunucu olabilirken başka bir
nesnenin istemcisi olabilir.
Aşağıda bu tanımı özetleyen, dağıtık nesnelerin, bir CORBA istemci ve sunucusu üzerinden bir metodu
nasıl paylaştıklarını gösteren klasik bir “Hello World” uygulaması görünmektedir.
İstemci tarafında, uygulama uzak nesnenin bir referansını içerir. Bu nesne referansı, uzaktan çağrılan
nesne metodunun bir vekil metoduna sahiptir.
Sunucu tarafından ise, ORB (Object Request Broker), uzaktan çağrıyı, yerel nesne üzerinde bir metot
çağrısıymış gibi yapmak için bir kod gövdesi (çatı) kullanır. Bu gövde, mevcut çağrıyı ve uygulamaya özel
formattaki parametreleri çevirir ve metodu çağırır. Yordam dönüşünde, gövde, sonuçları ve hataları
çevirerek çağrının geldiği istemciye tekrar, ORB’ yi kullanarak gönderir.
ORB’ler arasında iletişim, paylaşılan ortak bir protokol üzerinden (IIOP-Internet Inter ORB Protocol)
üzerinden sağlanır. IIOP, standart TCP/IP internet protokolü temel alınarak oluşturulmuş, ORB’ler arasında
bilgi aktarımını sağlamak için oluşturulmuş bir protokoldür. Tıpkı CORBA ve IDL gibi IIOP de OMG
tarafından tanımlanmış bir standarttır.
2.1 IDL
CORBA dil bağımsızlığını sağlar. Bir dilde yazılan CORBA nesnesi, başka bir dilde yazılan CORBA
nesnesine istem gönderebilir. Nesneye yönelik bir dilde yazılan CORBA nesnesi(örneğin Java veya
Smalltalk), C veya COBOL’da yazılan bir nesneyle konuşabilir, tersi de doğrudur.
CORBA'nın temelinde nesneye yönelimli dillerin uzaktan yordam çağırısı yapmasını sağlayan yapı
yatmaktadır. Bu çağrıyı yapabilmesi için hem sunucu tarafın hem de istemci tarafın ortak bir arayüzde
anlaşması lazımdır. Bu arayüzü dillerden ve platformlardan bağımsız bir şekilde tanımlayabilmek için,
CORBA bir tanımlama dili kullanmaktadır. Bu dile Interface Definition Language (IDL) denmektedir. Bu dil
sayesinde nesnenin arayüzü tanımlanır. IDL derleyicileri, bu tanımı, istemci tarafında "stub" oluşturmak
için, sunucu tarafta "skeleton" oluşturmak için kullanırlar. Üretilen bu kodları kullanarak, yapılan yordam
çağırıları, sanki yereldeki bir nesneden çağrı yapılıyor gibi kullanılabilir.
İşte bu yüzden, IDL, CORBA için anahtar özelliklerden birisidir. CORBA’yı destekleyen her dil, kendi IDL
eşleştirmesine sahiptir. Bu eşleştirmeler, OMG IDL’de tanımlanan CORBA türleri ile Java dilinin türleri
arasında gerçekleşir. Hazırlanan idl dosyaları, bu eşleştirmeler temel alınarak, Java'da “idlj” (idltojava)
derleyicisi ile Java kodlarına çevrilir. Ardından da elde edilen Java arayüzlerini gerçekleştiren kodlar ile
arayüzleri çağıracak olan kodlar yazılır. Bu sayede sunucu tarafında gövde kısmı bulunan kodlar, istemci
tarafındaki iskeletleri aracılığıyla işletilir.
Her CORBA satıcısı IDL tanımlarını özel bir dile çeviren derleyici sağlarlar. Oracle8i JServer, idl2java
derleyicisi kullanırlar. Idl2java derleyicisi, IDL ara yüzler tanımlarını Java sınıflarına çevirir.
2.2 OMA
IDL gerçekte bir alfabe vazifesi görmektedir. Bu sayede ortak bir dil oluşturarak CORBA karşılıklı işlerliğini
kurmak ve parça yazılımların modüler olarak kullanılmasını sağlar. OMG’nin OMA’sı IDL alfabesinden
türetilen ortak dili ifade eder. OMA karşılıklı işlerliği sistem seviyesinden uygulama seviyesine indirgeyen
bir ortam sağlar.
OMA’nın amacı uygulamaların getirdiği servisleri olası kullanıcılara standart bir arayüzle sağlamaktadır.
CORBA Servisleri herhangi bir nesnenin ihtiyaç duyabileceği tüm temel servisleri belirler. Bu servisler çok
daha evvelden gerçekleştirilmiş olup CORBA Üst Servisleri uygulamalar için orta seviyede servisler
sağlamaktadır ve daha yeni yeni tanımlanmıştır. En üst seviyedeki uygulama nesneleri OMG tarafından
değil yazılım geliştirici firmalarca gerçekleştirilmektedir. OMG OMA’nın her parçası için ayrı bir formal
tanımlama sağlamaktadır. Bu tanımlama
• Nesne işlemcilerinin nasıl çağrılacağını (OMG IDL’de hazırlanmış sözdizimi dokümanı) ve

• Her işlemin ne yaptığını içerir (İngilizce olarak hazırlanmış olan anlambilim dokumanı)
OMA uyumlu sistem geliştiricileri gerekli servisleri gerçekleştirerek kullanıma sunarlar. Ancak firmaların her
servisi gerçekleştirme zorunluluğu yoktur, sadece OMG tanımlamalarına uyma zorunlulukları vardır.
3- ORB
ORB (Object Request Broker) nesneler arasında veri değişimi ve iletişimini sağlayan bir orta katman
teknolojisidir. ORB dağıtık nesnelerin veri değişim ve bunları kullanabilme kapasitelerinin arttırıldığı bir
teknolojidir çünkü kullanıcıların birlikte olan nesneleri bölüp ORB’ler üzerinden haberleşebilecek şekilde
sistem geliştirmelerine olanak verirler. ORB‘nin gerçekleştirim ayrıntıları, dağıtık sistem geliştirenler
tarafından genellikle önemli değildir. Geliştiricilerin sadece nesne ara yüzleriyle ilgilenmeleri yeterlidir. Bilgi
gizlemenin bu yolu sistemin daha kaliteli olmasına neden olur çünkü nesne iletişim ayrıntıları
geliştiricilerden saklanır ve ORB içinde izole edilir.
ORB teknolojisi makine, yazılım ve satıcı kısıtları arasında nesne iletişimini amaç edinerek ilerler. ORB
teknolojisini ilgili fonksiyonları şunlardır;
• Ara yüz tanımı
• Uzak nesnelerin muhtemel aktivasyonları ve konumlandırmaları
• İstemci ve nesne arasındaki iletişim
ORB bir telefon santrali gibi davranır. Servisin dizinini sağlar ve bu servisler ile istemci arasında bir
bağlantı kurulmasına yardım eder.
ORB, sürekli ve etkili olarak birçok fonksiyonu desteklemek zorundadır. Fakat bu fonksiyonların çoğu ORB
kullanıcılarından gizlenmiş haldedir. Bu yer ilizyonunu sağlamak ORB’nin sorumluluğundadır. Başka bir
deyişle, geliştirici başka bir işlem ya da makine üzerinde sanki yerelde (local) çalışıyormuş gibi işlemlere
devam etme saydamlığına sahiptir. Bu yüzden ORB nesneler arasındaki cross - system iletişimi için bir
çatı sağlar. Bu, nesne sistemlerinin bilgilerini değiştirme ve kullanabilme yolundaki ilk teknik adımdır.
Nesne sistemleri bilgi değiş tokuşuna karsı diğer bir teknik adım da, platformlar arası nesne iletişimidir.
ORB, nesnelerin, gerçekleştirim detaylarını, istemcilerden gizlemesine izin verir. Bu, programlama dilini,
işletim sistemini, yerel donanım yapısını ve nesne konumunu kapsayabilir. Bütün bunlar “şeffaflık” olarak
düşünülebilir ve farklı ORB teknolojileri, farklı saydamlıkları destekleyebilir.
ORB kavramını uygulamanın birçok değişik yolu vardır. Örneğin, fonksiyonlar, istemciler için derlenebilir,
işlemlere dağıtılabilir veya bir işletim sisteminin çekirdeğine dâhil olabilir. Bu temel tasarım kararları tek bir
ürün içinde tanımlanabileceği gibi ORB uygulamacısının kararlarına bağlı olarak bir yelpaze içinde de yer
alabilir.
Ana olarak iki ORB teknolojisi vardır:

• OMG’nin (Object Management Group) CORBA (Common Object
Request Broker Architecture) spesifikasyonu
• Microsoft’un COM (Component Object Model) spesifikasyonu
ORB yapısının daha ayrıntılı bir çizimi aşağıda verilmiştir.
4- Dağıtık nesnelerde standart olarak CORBA

CORBA spesifikasyonundaki temel amaçlardan birisi de, istemci ve nesne gerçekleştirimini taşınabilir
yapmaktır. CORBA spesifikasyonları ayrıca dağıtık nesnelerle ilgilenen istemciler için ve CORBA
nesnelerinin gerçekleştirimleri için bir API tanımlar. Yani herhangi bir şirketin CORBA ürünü için yazılan bir
kod, minimum değişiklikle başka bir şirketin CORBA ürünü için yeniden yazılabilir. Fakat CORBA
ürünlerinde bugünün dünyasına baktığımız zaman CORBA istemcilerinin taşınabilir olduğunu görürüz ama
buna karşın nesne gerçekleştirimlerinin bir CORBA ürününden diğerine taşınırken belli miktarda yeniden
çalışma yapıldığı görülmektedir.
Bu bağlamda CORBA 2.0, IIOP (Internet Inter-ORB Protokol) adında, herhangi bir istemcinin herhangi bir
CORBA ürünü kullanarak, herhangi bir CORBA ürünü kullanan başka bir istemci ile iletişim kurabilmesine
olanak veren bir ağ protokolü tanımlamıştır. IIOP Internet üzerinden çalışan bir protokoldür.
İki sistem arasında bilgi değişilebilirliği ve değişildikten sonra da kullanılabilirliği (interoperability), dağıtık
sistemler için taşınabilirlikten daha önemlidir.
4.1 IIOP
IIOP (Internet Inter-ORB Protocol), farklı programlama, dillerinde yazılmış dağıtık programların Internet
üzerinden haberleşmelerini sağlayabilmek için geliştirilmiş bir protokoldür. IIOP, stratejik bir endüstri
standardı olan CORBA için kritik bir kesimdir. CORBA’nın IIOP protokolünü kullanarak bir şirket kendi
programlarıyla ya da başka bir şirketin programlarıyla, her nerede bulunursa bulunsun, program için
servisi ve adı dışında bir bilgiye gereksinim duymadan iletişim kurabilir.
CORBA ve IIOP sunucu/istemci modelini temel alan yaklaşımı kullanır. Buna göre bir istemci sürekli
istemde bulunurken sunucu program da istemcide istemleri alıp yanıtlamak için bekler. Programcı
programını yazarken GIOP (General Inter-ORB Protocol) adı verilen bir arayüz kullanır. GIOP bir veya
daha çok ağ iletişim katmanında mapping yapmak üzere gerçekleştirilmiştir.
İstemci tarafında, ağdaki herhangi bir bilgisayardaki bir programa istemde bulunmak için istemci program
için bir adres bilgisine sahip olmalıdır. Bu adres IOR (Interoperable Object Reference)olarak bilinir. IIOP
kullanılarak, adres sunucunun port numarası ve ip’sine dönüştürülür. İstemcinin bilgisayarında ise IOR leri
proxy isimlerine eslemek için bir tablo tutulur. Buradaki amaç ise kullanımı kolaylaştırmaktır. GIOP,
programa bir IOR ile bağlantı kurması için izin verir ve istemini gönderir. Daha sonra bir CDR (Common
Data Representation) veri için encode ve decode işlemlerini yaparak verinin standart bir şekilde
değişilmesini sağlar.
4.2 Java RMI
Uzak Metot Çağırımı (RMI) ilk olarak JDK 1.1 ile gündeme gelmiş ve ağ programlamayı daha yüksek
seviyelere taşımıştır. Uzak Metot Çağrımı’nın kullanımının nispeten kolay olmasının yanında fark edilir
güçte teknolojiler arasında gösterilebilir. Uzak Metot Çağrımı, ortalama Java geliştiricilerini dağıtık işlemler
dünyası adı verilen yeni bir değerler dizisi ile tanıştırmaktadır. Uzak Metot Çağrımı, dağıtık sistemlerdeki
klasik Uzak Yordam Çağırma mantığına benzer şekilde, uzaktaki bir bilgisayar üzerinde çalışan “Uzak
nesne ” nin metotlarını çağırabilmek olarak bilinmektedir. Diğer dağıtık programlama (Ara yüz Tanımlama
Dili (IDL), Uzak Yordam Çağırma (RPC), vb) aksine Java Uzak Metot Çağrımı (RMI), Java programlama
diline özgüdür.
Uzak Metot Çağrımı, dağıtılmış bir ortamda yerel çalışıyormuşçasına imkânlar sağlayan, uzaktan
nesnelere ileti göndermeye yarayan temel bir teknoloji olarak görülebilir. Büyük çaplı yazılımlar başarılarını
Uzak Metot Çağırımı’na borçludur. Bu tüy büyük çaptaki yazılımlarda Java RMI teknolojisi
kullanıldığından, istemci ve sunucu da Java programlama dili ile kodlanacağı için dağıtık programlama
tümüyle Java programlama dilinde gerçekleşmektedir. Böylelikle Java programlama dilinin özellikleri
avantajları dağıtık programlamada da kullanılabilmiş olmaktadır. Java RMI ağ işlemleri için kullanıcıya
soket ve streamlere göre daha üst düzeyde bir ara yüz sunmaktadır. Bu nedenle, RMI ile dağıtık
programlama yapmak soket ve stream kullanımına göre daha az karmaşıktır. Programcı açısından
bakıldığında, RMI kullanıldığında istemci/sunucu uygulamaların geliştirilmesi sırasında ağ işlem alt
düzeydeki ayrıntıları ile uğraşmak gerekmemektedir.
Çizim 1’de Java Sanal Makinesi–1 üzerinde bulunan bir Java uygulamasının, Java Sanal Makinesi–2
üzerinde bulunan Uzak Nesne isimli bir nesnenin Uzak_Metot() isimli bir metodunu çağrımı görülmektedir.
5- CORBA Servisleri
CORBA Servisleri nesneye yönelik uygulama ve parçalar için temel, sistem seviyesinde hizmetler
sağlamaktadır. Formal olarak sağlanan 15 servis aşağıda listelenmiştir. Bu servisler yeni sürümlerde
artmaktadır.
1. Yaşam döngüsü servisi.

2. Bağıntı servisi.
3. İsimlendirme servisi.
4. Kalıcı nesne servisi.
5. Globalizasyon servisi.
6. Event servisi.
7. Nesne sorgulama servisi.
8. Nesne karakteristikleri servisi.
9. Hareket servisi.
10. Paralel işleme servisi
11. Lisans servisi.
12. Güvenlik servisi.
13. Güvenli zaman servisi.
14. Ticaret servisi.
15. Nesne koleksiyon servisi.
Corba ve OMG IDL uygulamaların birbirlerine bağlandıkları telefon hattı ve alfabe olarak düşünülebilir.
6- CORBA Ürünleri
CORBA bir spesifikasyondur. Ürünlerin gerçekleştirimlerinde bir rehberdir. Birçok satıcı değişik
programlama dilleri için CORBA ürünleri sağlayabilir. Java programlama dilini destekleyen CORBA ürünü
şunları içerir.
ORB Açıklama
The Java 2 ORB Java 2 ORB, Sun’ın Java 2

SDK sı ile gelir.
VisiBroker for Java Inspire Corporation tarafından

popüler bir Java ORB. Netscape
Communicator web tarayıcı içine
gömülen ORB’dir.
OrbixWeb Lona Technologies tarafından

popüler bir Java ORB
WebSphere IBM tarafından ORB içeren popüler

bir uygulama sunucusu
Netscape Communicator Netscape, VisiBroker‘ın bir

sürümüne sahiptir. Appletler, web
tarayıcıya ORB sınıfları
yüklemeden CORBA nesnesi
üzerinden istem gönderebilir
7- CORBA ile Örnekler
7.1 Gereksinimler ve Kurulumlar
Kullanılan bileşenler aşağıdakilerdir:
 JDK 1.5.0 sürümü kullanılmıştır. www.java.com adresinden indirilebilir.

 IDE olarak Eclipse 3.2.1 kullanılmıştır. Eclipse’in bu sürümü www.eclipse.org adresinden
indirilebilir.
 Eclipse kullanılarak yazılımı geliştirmek için bir Eclipse eklentisine (plugin) ihtiyacımız var. Bunun
için ORB Studio 7 kullanılmıştır. www.orbzone.org/?p=125 adresinden indirilebilir.
 idl’i kullanarak CORBA uyumlu java sınıfları yaratan derleyici olarak JacORB-2.2.4 kullanılmıştır.
www.jacorb.org adresinden indirilebilir.
 Jacorb’dan yararlanabilmek için Apache Ant 1.6.5 kullanılmıştır. http://ant.apache.org adresinden
indirelebilir.
Gerekli Kurulumlar:
 Eclipse’in plugin klasörüne ORBStudio_7.7.5.jar eklentisi kopyalanır.
 Jacorb herhangi bir yere açılır. (extract). Yüklenen dizinde boşluk olmamasına dikkat edilir. Biz
bu örneğimizde C: dizinine açtık. (C:\JacORB-2.2.4)
 Apache Ant herhangi bir yere açılır. (extract). Yüklenen dizinde boşluk olmamasına dikkat edilir.
Biz bu örneğimizde C: dizinine açtık. (C:\apache-ant-1.6.5)
 Apache Ant ortam değişkenlerinden path değişkenine eklenir. ( ‘;’ ile ayrılıp Apache Ant’ın yüklü
olduğu dizinden bin klasörü gösterilir. )
 Konsoldan Jacorb ‘un bulunduğu dizine gidilir ve burada iki ant komutu çalıştırılır:
o ant jaco
o ant idlcmd
 Eclipse’de kullanacağımız idl derleyicisini jacorb olarak ayarlamamız gerekmektedir. Bunun için
Eclipse çalıştırılır. Window / Prefences seçeneği tıklandığında çıkan ekranda OrbStudio / IDL
compiler seçeneğindeki derleyici JacORB olarak değiştirilir.
 Bir önceki maddede anlatılan Window / Prefences / OrbStudio / IDL Compiler seçeneğine tekrar
gelinir ve alt seçeneklerden JacORB seçilir. Çıkan ekranda IDL command kısmına idl.bat ‘ın
bulunduğu yol yazılır. Command Options kısmında ise idl.jar ve logkit-1.2.jar yolları düzenlenir.
o IDL Command : C:\JacORB-2.2.4\bin\idl.bat

o Command Options : -cp "C:/JacORB-2.2.4/lib/idl.jar;C:/JacORB-2.2.4/lib/logkit-
1.2.jar" org.jacorb.idl.parser -d %D% %F%
 Uygulamamız çalışmaya hazır hale gelmiştir. Gerekli idl kütüğü artık yazılabilir.
7.2 Hello World Uygulaması
Bu örneğimizde Java IDL kullanarak örnek bir CORBA dağıtık uygulamanın nasıl gerçekleştirildiğini
göreceğiz. Adım adım klasik bir “Hello World” uygulaması geliştireceğiz. Hello World programı, basılmak
üzere bir katar döndüren sadece bir eylem gerçekleştirir.
Uygulamadaki adımları daha iyi anlamak açısından CORBA yapısını tekrar gözden geçirmekte fayda
vardır.
1- İstemci, Hello Server’ın sayHello metodunu çağırır.

2- ORB, bu çağrıyı IDL ara yüzü için kayıtlı hizmet veren nesneye transfer eder.
3- Hizmeti sunan nesnenin sayHello metodu çalıştırılır. Karşılığında bir Java String tipinde nesne döner.
4- ORB, bu String tipindeki nesneyi tekrar istemciye yönlendirir.
5- İstemci String tipindeki nesnenin değerini yazdırır. Basit tasarımına karsın bu uygulama temel bir
CORBA uygulaması geliştirmek için gereken altyapıyı sağlar.
• IDL ara yüzünü yazmak
Bu bölümde Hello World uygulaması için basit bir IDL ara yüzü yazacağız. IDL ara yüzü, uygulamamızdaki
istemci ve sunucu kesimi için etkiletişimi sağlar. OMG IDL programlama dilinden bağımsız bir kesimdir.
Herhangi bir gerçekleştirime yönelik kodlamadan önce IDL’ i Java’ya “map” etmemiz gerekir.
• “Hello. idl”’i yazmak
Hello World için yazılması gereken IDL oldukça basittir. Bunun için aşağıda belirtilen üç adımları
uygulamak yeterlidir.
Adım 1: CORBA IDL modülünü tanımlamak
a) Eclipse’de yeni bir java projesi açın ve bu projeye bir Simple IDL kütüğü ekleyin (Hello.idl).
b) Kütük içine aşağıdaki modül satırlarını girin.
module HelloApp {
// Sonraki kodları buraya ekleyin.
};
• Arayüzü tanımlamak
Hello.idl kütüğünün içine aşağıdaki ara yüz deyimlerini yazın.
module HelloApp {
interface Hello // Bu
{ // dört
// satırı
}; // ekleyin.
}
IDL’i derlediğiniz zaman, bu deyim Java kodunda bir ara yüz deyimi oluşturacaktır. Sunucu ve istemci
sınıfları Hello ara yüzünü değişik yollardan implement edecektir.
• Metotları tanımlamak
CORBA işlemleri, sunucuların istemci namına gerçekleştirmeye söz verdiği davranışlardır. IDL türündeki
her işlem deyimi, üretilen Java ara yüzündeki ilgili metot deyimini üretir. Hello.idl kütüğüne aşağıdaki ara
yüz deyimlerini ekleyin.
module HelloApp {
interface Hello
{
string sayHello(); // Bu satırı ekleyin.
};
};
Çünkü bizim küçük Hello World uygulamamız sadece bir tane işlem içerir. Hello.idl şimdi son halini
almıştır.
“Hello.idl”’i “IDL”’den “Java”’ya çevirmek
Hello.idl üzerinde sağ tuş yapıp ORB Menu’den Compile seçeneğini tıklayalım, bu IDLimizi derleyecektir.
IDL’i derlediğiniz zaman, yukarıdaki tüm deyimler HelloApp paketi içerisinde Java kodlarına dönüşecektir.
Eğer dizinin içeriğini listelerseniz, HelloApp adlı dizinin yaratıldığını ve içerisinde de 7 tane kütük
bulunduğunu göreceksiniz. Hello.java kütüğünü bir metin editörü ile açarsanız şu satırlarla karsılaşırsınız.
package HelloApp;
/**
* Generated from IDL interface "Hello"
* @author JacORB IDL compiler V 2.2.3, 10-Dec-2005
*/
public interface Hello

extends HelloOperations, org.omg.CORBA.Object,
org.omg.CORBA.portable.IDLEntity
{
}
• İstemci Uygulamayı Geliştirmek
CORBA istemcisinin temel yapısı birçok Java uygulamasından farklı değildir. Gerekli paketleri ekleyin, bir
uygulama sınıfı tanımlayın, bir main metodu tanımlayın, istisnaları yakalamayı da unutmayın.
*Gerekli Paketlerin Eklenmesi

Projemize “implementation” adında bir paket ekleyin ve bir java kütüğünü HelloClient.java olarak kaydedin.
Daha sonra gerekli paketleri ekleyin:
package implementation;
import HelloApp.*; // stub altyapısını saglamak için.
import org.omg.CosNaming.*; // HelloClient isimlendirme servisini kullanır
import org.omg.CORBA.*; // Bütün CORBA uygulamaları buna ihtiyaç duyar
*Main metodunun tanımlanması
Her Java uygulaması main metoduna ihtiyaç duyar. Main metodunu HelloClient.java sınıfının etkinlik alanı
içinde aşağıdaki gibi tanımlayın.
public static void main(String args[]) {

// Daha sonra buraya try-catch blogu ekleyin
}
*CORBA Sistem İstisnalarını Ele Almak
Bütün CORBA uygulamalarının çalışma anında CORBA sistem hatasını fırlatabileceğini göz önüne alarak,
main içindeki tüm kodu try-catch bloğuna almamız gerekir. İstisna yakalayıcımız sadece istisnanın ismini
yazdırır ve yığıt izini ekrana basar.
try {
// HelloClient kodu buraya yazılacaktır.
} catch(Exception e) {
System.out.println("ERROR : " + e);
e.printStackTrace(System.out);
}
*Bir ORB Nesnesi Yaratmak
Bir CORBA istemcisi, bütün marchalling ve IIOP işlemlerini gerçekleştirmek için yerel bir ORB nesnesine
ihtiyacı vardır.
HelloClient sınıfının içinde, try-catch bloğunun içine bir ORB değişkeni tanımlayalım.
org.omg.CORBA.ORB orb = org.omg.CORBA.ORB.init(args, null);
ORB’nin init metodunu çağırmak, uygulamamızın komut satırı argümanlarını aktarmaya yarar ve çalışma
anında kesin özellikleri değiştirmemize izin verir.
PoaManager’i aktif hale getirmek için aşağıdaki kod bloğunu ekleyin.
org.omg.PortableServer.POA poa = org.omg.PortableServer.POAHelper

.narrow(orb.resolve_initial_references("RootPOA"));
poa.the_POAManager().activate();
*Hello Sunucusunu Bulmak
CORBA istemcisi için bir ilk nesne referansı almak için çeşitli yolar vardır. Bizim uygulamamız bunun için
COS isimlendirme servisini kullanacaktır. COS, OMG tarafından tanımlanmış ve Java IDL destekleyen bir
servistir.
NameServer bütün CORBA ORB’leri için tanımlı bir katardır. Bu kadarı parametre olarak geçtiğimiz
zaman, ORB bir naming context döndürür.
NamingContextExt nc = NamingContextExtHelper.narrow(orb
.resolve_initial_references("NameService"));
Hello sunucusunu bulabilmek için öncelikle Hello sunucusunun kimliğini tanımlayan, bir
NameComponent’a ihtiyaç vardır.
NameComponent[] helloName = new NameComponent[1];

helloName[0] = new NameComponent("Hello", "server");
Hello nesnesine olan yol sadece bir element içerdiği için, nc üstünden tek elemanlı bir dizi oluşturulur.
Son olarak, Hello sunucusuna bir referans almak için ve bunu Hello nesnesine vermek için, isim servisin
resolve metoduna gerekli yol paramatre olarak geçilir.
Hello hello = HelloHelper.narrow(nc.resolve(helloName));
• sayHello() işlemini çağırmak
 HelloClient.java içinde, try-catch bloğunun içine isim servisinin resolve metodunu

çağırmak için aşağıdaki çağrı yapılır.
String Hello = hello.sayHello();
 Son olarak da sonuç ekrana bastırılır.
System.out.println(Hello);
 Kütük kaydedilir ve kapatılır (HelloClient.java)
• HelloWorld sunucusunun geliştirilmesi
Projemize HelloServer.java isminde bir kütük yaratın. Sonra aşağıdaki paketleri ekleyin.
*Gerekli paketleri eklemek
import HelloApp.*;
// HelloServer isimlendirme servisini kullanacak.
import org.omg.CosNaming.*;
import org.omg.CosNaming.NamingContextPackage.*;
// Bütün CORBA uygulamalı bu paketi kullanır.
import org.omg.CORBA.*;
• Sunucu sınıfını tanımlamak
public class HelloServer {

// kodlar buraya.
}
*CORBA sistem hatalarını ele almak
Main içine aşağıdaki try-catch bloğunu ekleyin.
try {
// HelloServer kodları buraya eklenecektir
System.err.println("ERROR: " + e);
}
*ORB nesnesini yaratmak
İstemci gibi sunucu uygulama da yerel bir ORB nesnesine ihtiyaç duyar.
ORB orb = ORB.init(args, null);
PoaManager’i aktif hale getirmek için aşağıdaki kod bloğunu ekleyin.

Hizmet edecek sınıf hala tanımlanmadı. Bunu daha sonraki adımlarda yapacaksınız. Bir sonraki adımda
nesnemizi ORB’ye bağlayacağız. Böylece ORB gelen çağrıların farkına varıp bu çağrıları doğru hizmet
eden sınıfa aktarabilir.
org.omg.CORBA.Object helloObject = poa

.servant_to_reference(new HelloServant(orb));
• Hizmetçi sınıfı tanımlamak
o Sınıfı tanımlayın.
class HelloServant extends HelloPOA{

// sayHello metodunu burada olusturun.
}
o Hizmetçi sınıf HelloPOA sınıfının alt sınıfıdır. Bu yüzden derleyici tarafından bütün
CORBA fonksiyonelliği kalıtılır.
o Gerekli sayHello metodunu tanımlayın.
public String sayHello() {

//metot tanımını burada olusturun
}
o sayHello tanımını olusturun.
return "\nHello World!!\n";
• COS isimlendirme servisi ile çalışmak
Yeni bir NameComponent nesnesi yaratın.
NameComponent[] hello = new NameComponent[1];

hello[0] = new NameComponent("Hello", "server");
Hello nesnesine olan yol sadece bir element içerdiği için, nc üstünden tek elemanlı bir dizi oluşturulur.
Son olarak yolu ve hizmetçi sınıfı isimlendirme servisine geçin ve nesneyi “Hello” id’si ile bağlatın.
nc.rebind(hello, helloObject);
Sunucumuz hazır. Tek ihtiyacı olan çevrede ihtiyacı olan istemcilerden istem beklemektir. Bunun için try-
catch bloğunun sonuna aşağıdaki kod kesimi eklenir.
java.lang.Object sync = new java.lang.Object();

synchronized(sync) {
sync.wait();
}
Uygulamamızı Çalıştırmak
• Uygulamayı derlemek ve çalıştırmak
Eclipse Hello.idl’imizi derledikten sonra java kodlarımızda otomatik olarak derlenir. Java kütüklerinin .class
uzantılı kütükleri oluşur.
Uygulamayı Çalıştırmak:
• Windows için komut satırını açın ve Java IDL isim servisini başlatın.
tnameserv -ORBInitialPort 1050
• Sunucu’yu -ORBInitialPort 1050 parametresiyle çalıştırın. Eclipse’te Run özelliklerine gidilerek

parametre yazılabilir.
• İstemciyi -ORBInitialPort 1050 parametresiyle çalıştırın. Eclipse’te Run özelliklerine gidilerek

• İstemci aşağıdaki katarı ekrana basar.
Hello world!!
NameServer’ı ve HelloServer’ı istemci uygulama başarıyla sonuçlandıktan sonra sonlandırmayı

unutmayın.
Uygulamada anlatılan java kodları aşağıda verilmiştir.
1) Hello.idl
module HelloApp
{
interface Hello
{
string sayHello();
};
};
2) HelloClient.java
import org.omg.CosNaming.NameComponent;
import org.omg.CosNaming.NamingContextExt;
import org.omg.CosNaming.NamingContextExtHelper;
import HelloApp.HelloHelper;
import HelloApp.Hello;
public class HelloClient {
public static void main(String[] args) {

try{
Hello hello;
org.omg.PortableServer.POA poa =
org.omg.PortableServer.POAHelper
NameComponent[] helloName = new NameComponent[1];

helloName[0] = new NameComponent("Hello", "server");
hello = HelloHelper.narrow(nc.resolve(helloName));
String Hello = hello.sayHello();

System.out.println(Hello);
}
catch (Exception e) {
e.printStackTrace();
}
}
}
3) HelloServer.java
import org.omg.CORBA.*;
//import org.omg.CosNaming.NamingContextPackage.*;
public class HelloServer {

public static void main(String args[])
{
try{
// Create and initialize the ORB
ORB orb = ORB.init(args, null);

org.omg.CORBA.Object helloObject = poa

.servant_to_reference(new HelloServant(orb));
NameComponent[] hello = new NameComponent[1];

hello[0] = new NameComponent("Hello", "server");
nc.rebind(hello, helloObject);
// Wait for invocations from clients

java.lang.Object sync = new java.lang.Object();
synchronized(sync){
sync.wait();
}
orb.run();
System.err.println("ERROR: " + e);
}
}
}
7.3 Banka Uygulaması
Bu örneğimizde basit bir banka uygulaması gerçekleştirilmiştir.

1. Banka (BankSystem), Müşteri (Customer) ve Hesap (Account) öğelerimiz bulunmaktadır.
2. Banka’da kayıtlı müşteriler ve hesaplar bulunmaktadır.
3. Banka müşteri ekleme, müşteri silme, hesap ekleme, hesap silme işlemleri yapmaktadır.
4. Her müşterinin bir idsi, ismi ve hesapları bulunmaktadır.
5. Her hesabın bir idsi ve hesap limiti bulunmaktadır.
6. Banka sunucu tarafında çalışmaktadır.
7. İstemci, bankanın(sunucunun) işlevlerinden yararlanır. (Hesap ekleme, müşteri ekleme…)
• Bank.idl’in oluşturulması:
 Eclipse’te projemize Simple IDL kütüğü ekleyin ve aşağıdaki modül satırlarını girin. Aşağıdaki
Bank modülünde Hesap (Account), Müşteri (Customer) ve Banka (BankSystem) arayüzleri
tanımlanmıştır.
module Bank{
interface Account{
attribute long accountId;
attribute long accountLimit;
};
typedef sequence<Account> AccountList;
interface Customer{
attribute string customerName;
attribute long customerId;
boolean openCustomerAccount(in Account account);

AccountList getCustomerAccounts(in long customerId);
};
interface BankSystem{
Customer createCustomer(in string customerName, in long

customerId);
boolean deleteCustomer(in long customerId);
Account createAccount(in long accountId, in long accountLimit);

boolean deleteAccount(in long accountId);
};
};
Her tanımlı arayüz içerisinde gerekli işlevlerin tanımına yer verilmiştir.

 Bank.idl üzerinde sağ tuş yapıp ORB Menu’den Compile seçeneğini tıklayalım, bu IDLimizi
derleyecektir. IDL’i derlediğiniz zaman, yukarıdaki tüm deyimler Bank paketi içerisinde Java
kodlarına dönüşecektir.
 Oluşan arayüzlere karşılık gerçekleştirimler için “implementation” adında paket oluşturun.

Gerçekleştirimler aşağıdaki şekilde doldurulur. Bunlar basit hesap ekleme, hesap silme, hesap
açma, müşteri ekleme, müşteri silme işlemleridir.
AccountImplementation.java:
import Bank.AccountPOA;
public class AccountImplementation extends AccountPOA {
private int accountId;

private int accountLimit;
public AccountImplementation(int accountId, int accountLimit){

accountId(accountId);
accountLimit(accountLimit);
}
public int accountId() {

return this.accountId;
}
public void accountId(int newAccountId) {

this.accountId = newAccountId;
}
public int accountLimit() {

return this.accountLimit;
}
public void accountLimit(int newAccountLimit) {

this.accountLimit = newAccountLimit;
}
}
BankSystemImplementation.java:
import java.util.ArrayList;
import org.omg.CORBA.ORB;
import Bank.Account;
import Bank.BankSystemPOA;
import Bank.Customer;
public class BankSystemImplementation extends BankSystemPOA {
private ORB orb;

ArrayList<CustomerImplementation> customerArray;
ArrayList<AccountImplementation> accountArray;
public BankSystemImplementation(org.omg.CORBA.ORB orb){

this.orb = orb;
customerArray = new ArrayList<CustomerImplementation>();
accountArray = new ArrayList<AccountImplementation>();
}
public Account createAccount(int accountId, int accountLimit) {

AccountImplementation accImp = new
AccountImplementation(accountId,accountLimit);
accountArray.add(accImp);
return accImp._this(orb);
}
public Customer createCustomer(String customerName, int customerId) {

CustomerImplementation cusImp = new
CustomerImplementation(customerName,customerId);
customerArray.add(cusImp);
return cusImp._this(orb);
}
public boolean deleteAccount(int accountId) {
for(int i=0;i<accountArray.size();++i)
System.out.println(accountArray.get(i).accountId());
boolean isDeleted = false;

for(int i=0;i<accountArray.size();++i){
if(accountArray.get(i).accountId() == accountId){
accountArray.remove(i);
isDeleted = true;
}
}
System.out.println("after deleting account");
for(int i=0;i<accountArray.size();++i)
System.out.println(accountArray.get(i).accountId());
return isDeleted;
}
public boolean deleteCustomer(int customerId) {
for(int
Belgeye i=0;i<customerArray.size();++i)
ilişkin eleştiri ve önerilerinizi lütfen Ar. Gör. Fatih M. GÜLEÇ’e bildirin. 26
CustomerImplementation.java:
import Bank.CustomerPOA;
import java.util.ArrayList;
public class CustomerImplementation extends CustomerPOA {
private int customerId;

private String customerName;
private ArrayList<Account> customerAccounts = new ArrayList<Account>();
public CustomerImplementation(String customerName, int customerId){

customerName(customerName);
customerId(customerId);
}
public int customerId() {

return this.customerId;
}
public void customerId(int newCustomerId) {

this.customerId = newCustomerId;
}
public String customerName() {

return this.customerName;
}
public void customerName(String newCustomerName) {

this.customerName = newCustomerName;
}
public Account[] getCustomerAccounts(int customerId) {

return this.customerAccounts.toArray(new
Account[customerAccounts.size()]);
}
public boolean openCustomerAccount(Account account) {

customerAccounts.add(account);
return true;
}
}
Sunucu ve İstemci’nin oluşturulması:

 Bir önceki örneğimizdeki gibi isimlendirme servisi, ORB nesne yaratımı gibi kriterlere dikkat
ederek aşağıdaki kodu Sunucu (Server) sınıfı içerisine yerleştirin.
Server.java
public class Server {

public static void main(String args[]){
try{
System.out.println("Server calisti");
org.omg.PortableServer.POA poa =
org.omg.PortableServer.POAHelper.narrow(orb.resolve_initial_references("RootPOA
"));
org.omg.CORBA.Object bankSystemObject =
poa.servant_to_reference(new BankSystemImplementation(orb));
NamingContextExt nc =
NamingContextExtHelper.narrow(orb.resolve_initial_references("NameService"));
NameComponent[] bankSystemName = new NameComponent[1];
bankSystemName[0] = new NameComponent("BankSystem", "server");
nc.rebind(bankSystemName, bankSystemObject);
}
catch(Exception e){
}
orb.run();
}
}
 Bir önceki örneğimizdeki gibi isimlendirme servisi, ORB nesne yaratımı gibi kriterlere dikkat
ederek aşağıdaki kodu İstemci (Client) sınıfı içerisine yerleştirin.
Client.java
import org.omg.CosNaming.NameComponent;
import org.omg.CosNaming.NamingContextExt;
import org.omg.CosNaming.NamingContextExtHelper;
import Bank.BankSystem;
import Bank.BankSystemHelper;
import Bank.Customer;
public class Client {

public static void main(String args[]){
try{
System.out.println("Client calisti");
BankSystem bankSystem;
NamingContextExt nc =
NamingContextExtHelper.narrow(orb.resolve_initial_references("NameService"));
NameComponent[] bankSystemName = new NameComponent[1];
bankSystemName[0] = new NameComponent("BankSystem", "server");
bankSystem =
BankSystemHelper.narrow(nc.resolve(bankSystemName));
Account account = bankSystem.createAccount(123456, 1000);

Customer customer = bankSystem.createCustomer("Yusuf
Kartal",98765432);
customer.openCustomerAccount(account);
Account[] accountList =
customer.getCustomerAccounts(987654321);
for(int i=0; i<accountList.length; ++i)
System.out.println("account ID: " +
accountList[i].accountId());
Customer customer2 = bankSystem.createCustomer("Dogukan

Dogan",88885432);
bankSystem.deleteCustomer(88885432);
Account account2 = bankSystem.createAccount(111156, 1000);

bankSystem.deleteAccount(111156);
}
catch(Exception e){
}
}
}
Uygulamamızın Çalıştırılması:
 Komut satırını açın ve Java IDL isim servisini başlatın.
o tnameserv –ORBInitialPort 1050
 Sunucu’yu -ORBInitialPort 1050 parametresiyle çalıştırın. Eclipse’te Run özelliklerine gidilerek

 İstemciyi -ORBInitialPort 1050 parametresiyle çalıştırın. Eclipse’te Run özelliklerine gidilerek

 Program aşağıdaki gibi çıktı üretecektir:
Server calisti
Yusuf Kartal
Dogukan Dogan
after deleting customer
Yusuf Kartal
123456
111156
after deleting account
8- Kaynaklar
ftp.cs.hacettepe.edu.tr/pub/dersler/BIL4XX/BIL447_YML/belgeler/Java_IDL.pdf
ftp.cs.hacettepe.edu.tr/pub/dersler/BIL4XX/BIL447_YML/belgeler/CORBA_20122034.pdf
http://www.objs.com/
http://java.sun.com/docs/books/tutorial/idl/intro/corba.html
http://www.omg.org/gettingstarted/corbafaq.htm
http://tr.wikipedia.org/wiki/CORBA
http://www.sei.cmu.edu/str/descriptions/orb.html
http://whatis.techtarget.com/definition/0,,sid9_gci214019,00.html
http://searchwebservices.techtarget.com
http://www.corba.org/

1CORBA

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

1CORBA

Uploaded by

Copyright:

Available Formats

Hacettepe Üniversitesi

Ekip İsim - Soyisim E-Posta Tarih

• Nesne işlemcilerinin nasıl çağrılacağını (OMG IDL’de hazırlanmış sözdizimi dokümanı) ve

Ana olarak iki ORB teknolojisi vardır:

• Microsoft’un COM (Component Object Model) spesifikasyonu

ORB yapısının daha ayrıntılı bir çizimi aşağıda verilmiştir.

4- Dağıtık nesnelerde standart olarak CORBA

4.2 Java RMI

1. Yaşam döngüsü servisi.

The Java 2 ORB Java 2 ORB, Sun’ın Java 2

VisiBroker for Java Inspire Corporation tarafından

OrbixWeb Lona Technologies tarafından

WebSphere IBM tarafından ORB içeren popüler

Netscape Communicator Netscape, VisiBroker‘ın bir

7- CORBA ile Örnekler

7.1 Gereksinimler ve Kurulumlar

Kullanılan bileşenler aşağıdakilerdir:

 JDK 1.5.0 sürümü kullanılmıştır. www.java.com adresinden indirilebilir.

o IDL Command : C:\JacORB-2.2.4\bin\idl.bat

7.2 Hello World Uygulaması

1- İstemci, Hello Server’ın sayHello metodunu çağırır.

• IDL ara yüzünü yazmak

• “Hello. idl”’i yazmak

Adım 1: CORBA IDL modülünü tanımlamak

Hello.idl kütüğünün içine aşağıdaki ara yüz deyimlerini yazın.

“Hello.idl”’i “IDL”’den “Java”’ya çevirmek

public interface Hello

• İstemci Uygulamayı Geliştirmek

*Gerekli Paketlerin Eklenmesi

*Main metodunun tanımlanması

public static void main(String args[]) {

*CORBA Sistem İstisnalarını Ele Almak

*Bir ORB Nesnesi Yaratmak

org.omg.CORBA.ORB orb = org.omg.CORBA.ORB.init(args, null);

PoaManager’i aktif hale getirmek için aşağıdaki kod bloğunu ekleyin.

org.omg.PortableServer.POA poa = org.omg.PortableServer.POAHelper

*Hello Sunucusunu Bulmak

NameComponent[] helloName = new NameComponent[1];

Hello hello = HelloHelper.narrow(nc.resolve(helloName));

• sayHello() işlemini çağırmak

 HelloClient.java içinde, try-catch bloğunun içine isim servisinin resolve metodunu

String Hello = hello.sayHello();

 Son olarak da sonuç ekrana bastırılır.

 Kütük kaydedilir ve kapatılır (HelloClient.java)

• HelloWorld sunucusunun geliştirilmesi

*Gerekli paketleri eklemek

• Sunucu sınıfını tanımlamak

public class HelloServer {

*CORBA sistem hatalarını ele almak

Main içine aşağıdaki try-catch bloğunu ekleyin.

*ORB nesnesini yaratmak

ORB orb = ORB.init(args, null);

PoaManager’i aktif hale getirmek için aşağıdaki kod bloğunu ekleyin.

org.omg.PortableServer.POA poa = org.omg.PortableServer.POAHelper

org.omg.CORBA.Object helloObject = poa

• Hizmetçi sınıfı tanımlamak

class HelloServant extends HelloPOA{

o Gerekli sayHello metodunu tanımlayın.

public String sayHello() {

o sayHello tanımını olusturun.

return "\nHello World!!\n";

• COS isimlendirme servisi ile çalışmak

Yeni bir NameComponent nesnesi yaratın.

NameComponent[] hello = new NameComponent[1];