4. Randevular için J2EE web hizmeti

Şimdi, geliştirilecek uygulamanın mimarisine geri dönelim:

Bu bölümde, Sun / Glassfish sunucusunda çalıştırılan J2EE [1] web hizmetinin oluşturulmasına odaklanacağız.

4.1. Veritabanı

[dbrdvmedecins] olarak adlandıracağımız veritabanı, dört tablo içeren bir MySQL5 veritabanıdır:

4.1.1. [MEDECINS] tablosu

Bu tablo, [RdvMedecins] uygulaması tarafından yönetilen doktorlar hakkında bilgiler içerir.

• ID: doktoru tanımlayan numara – tablonun birincil anahtarı
• VERSION: Tablodaki satırın sürümünü tanımlayan numara. Bu sayı, satırda her değişiklik yapıldığında 1 artırılır.
• NOM: doktorun soyadı
• PRENOM: doktorun adı
• TITRE: unvanı (Bayan, Bayan, Bay)

4.1.2. [CLIENTS] tablosu

Farklı doktorların hastaları [CLIENTS] tablosunda kaydedilir:

• ID: müşteriyi tanımlayan numara - tablonun birincil anahtarı
• VERSION: Tablodaki satırın sürümünü tanımlayan numara. Bu sayı, satırda her değişiklik yapıldığında 1 artırılır.
• NOM: müşterinin adı
• PRENOM: müşterinin adı
• TITRE: unvanı (Bayan, Bayan, Bay)

4.1.3. [CRENEAUX] tablosu

Bu tablo, RV'lerin mümkün olduğu zaman aralıklarını listeler:

• ID: zaman aralığını tanımlayan numara - tablonun birincil anahtarı (satır 8)
• VERSION: Tablodaki satırın sürümünü tanımlayan numara. Bu sayı, satırda her değişiklik yapıldığında 1 artırılır.
• ID_MEDECIN: Bu zaman diliminin ait olduğu doktoru tanımlayan numara – MEDECINS (ID) sütunundaki yabancı anahtar.
• HDEBUT: zaman aralığının başlangıç saati
• MDEBUT: zaman aralığının başlangıç dakikası
• HFIN: zaman aralığının bitiş saati
• MFIN: zaman aralığının bitiş dakikası

[CRENEAUX] tablosunun ikinci satırı (yukarıdaki [1]'e bakınız), örneğin, 2 numaralı zaman diliminin saat 08:20'de başlayıp 08:40'ta bittiğini ve 1 numaralı doktora ait olduğunu gösterir (Bayan Marie PELISSIER) ait olduğunu gösterir.

4.1.4. [RV] tablosu

Bu tablo, her doktor için ayrılan RV'leri listeler:

• ID: RV'i benzersiz şekilde tanımlayan numara – birincil anahtar
• JOUR: RV'in günü
• ID_CRENEAU: RV'in zaman aralığı – [CRENEAUX] tablosundaki [ID] alanına yabancı anahtar – hem zaman aralığını hem de ilgili doktoru belirler.
• ID_CLIENT: Rezervasyonun yapıldığı müşterinin numarası – [CLIENTS] tablosundaki [ID] alanında yabancı anahtar

Bu tablo, birleştirilen sütunların değerleri (JOUR, ID_CRENEAU) üzerinde tekillik kısıtlaması içeren bir 'e sahiptir:

ALTER TABLE RV ADD CONSTRAINT UNQ1_RV UNIQUE (JOUR, ID_CRENEAU);

[RV] tablosundaki bir satırın değeri (JOUR1, ID_CRENEAU1) değerine sahipse, bu değer başka hiçbir yerde bulunamaz. Aksi takdirde, bu durum aynı hekim için aynı anda iki adet RV'in alınmış olduğu anlamına gelir. Java programlama açısından bakıldığında, veritabanındaki JDBC sürücüsü, bu durum meydana geldiğinde bir SQLException başlatır.

id satırındaki 3 değeri (yukarıdaki [1]'e bakınız), 23/08/2006 tarihinde 20 numaralı zaman dilimi ve 4 numaralı müşteri için bir RV'in rezerve edildiği anlamına gelir. [CRENEAUX] tablosundan, 20 numaralı randevu aralığının 16:20 - 16:40 saat aralığına karşılık geldiği ve 1 numaralı hekime (Bayan Marie PELISSIER) ait olduğu anlaşılmaktadır. [CLIENTS] tablosundan, 4 numaralı müşterinin Bayan Brigitte BISTROU olduğu anlaşılmaktadır.

4.2. Veritabanının oluşturulması

MySql ve [dbrdvmedecins] veritabanlarını istediğiniz bir araçla oluşturun. Tabloları oluşturmak ve verilerle doldurmak için size sağlanacak olan [createbd.sql] komut dosyasını kullanabilirsiniz. İçeriği şöyledir:

create table CLIENTS (
        ID bigint not null auto_increment,
        VERSION integer not null,
        TITRE varchar(5) not null,
        NOM varchar(30) not null,
        PRENOM varchar(30) not null,
        primary key (ID)
    ) ENGINE=InnoDB;

    create table CRENEAUX (
        ID bigint not null auto_increment,
        VERSION integer not null,
        HDEBUT integer not null,
        MDEBUT integer not null,
        HFIN integer not null,
        MFIN integer not null,
        ID_MEDECIN bigint not null,
        primary key (ID)
    ) ENGINE=InnoDB;

    create table MEDECINS (
        ID bigint not null auto_increment,
        VERSION integer not null,
        TITRE varchar(5) not null,
        NOM varchar(30) not null,
        PRENOM varchar(30) not null,
        primary key (ID)
    ) ENGINE=InnoDB;

    create table RV (
        ID bigint not null auto_increment,
        JOUR date not null,
        ID_CLIENT bigint not null,
        ID_CRENEAU bigint not null,
        primary key (ID)
    ) ENGINE=InnoDB;

    alter table CRENEAUX 
        add index FK9BD7A197FE16862 (ID_MEDECIN), 
        add constraint FK9BD7A197FE16862 
        foreign key (ID_MEDECIN) 
        references MEDECINS (ID);

    alter table RV 
        add index FKA4494D97AD2 (ID_CLIENT), 
        add constraint FKA4494D97AD2 
        foreign key (ID_CLIENT) 
        references CLIENTS (ID);

    alter table RV 
        add index FKA441A673246 (ID_CRENEAU), 
        add constraint FKA441A673246 
        foreign key (ID_CRENEAU) 
        references CRENEAUX (ID);

INSERT INTO CLIENTS ( VERSION, NOM, PRENOM, TITRE) VALUES (1, 'MARTIN', 'Jules', 'Mr');
...

INSERT INTO MEDECINS ( VERSION, NOM, PRENOM, TITRE) VALUES (1, 'PELISSIER', 'Marie', 'Mme');
...

INSERT INTO CRENEAUX ( VERSION, ID_MEDECIN, HDEBUT, MDEBUT, HFIN, MFIN) VALUES (1, 1, 8, 0, 8, 20);
...

INSERT INTO RV ( JOUR, ID_CRENEAU, ID_CLIENT) VALUES ('2006-08-22', 1, 2);
...

ALTER TABLE RV ADD CONSTRAINT UNQ1_RV UNIQUE (JOUR, ID_CRENEAU);

COMMIT WORK;

4.3. Sunucu tarafı mimarisinin bileşenleri

Oluşturulacak uygulamanın mimarisine geri dönelim:

Sunucu tarafında, uygulama şu şekilde oluşacaktır:

1. BD ile nesneler aracılığıyla çalışmayı sağlayan bir JPA katmanından

2. JPA katmanıyla yapılan işlemleri yönetmekten sorumlu bir EJB
3. uzak istemcilere EJB arayüzünü bir web hizmeti biçiminde sunmaktan sorumlu bir web hizmeti.

(b) ve (c) öğeleri, önceki şemada gösterilen [dao] katmanını uygular. Bir uygulamanın, RMI ve JNDI protokolleri aracılığıyla uzak bir EJB'ye erişebileceği bilinmektedir. Uygulamada bu durum, istemcileri Java istemcileriyle sınırlamaktadır. Bir web hizmeti, çeşitli diller tarafından uygulanan standart bir iletişim protokolü kullanır: .NET, PHP, C++, ... Burada bir .NET istemcisi kullanarak bunu göstermek istiyoruz.

Web hizmetlerine ilişkin kısa bir giriş için [ref1] dersinin 14. paragrafı, sayfa 109'a bakabilirsiniz.

Bir web hizmeti iki şekilde uygulanabilir:

• bir web kapsayıcısında çalışan @WebService ile etiketlenmiş bir sınıf aracılığıyla

• EJB kapsayıcısında çalışan @WebService anotasyonlu bir EJB aracılığıyla

Burada ilk çözümü kullanacağız:

[ref1] dersinin 109. sayfasındaki 14. paragrafta, ikinci çözümü kullanan bir örnek bulabilirsiniz.

4.4. Glassfish sunucusunun Hibernate yapılandırması

Sürümüne bağlı olarak, NetBeans ile birlikte gelen Glassfish V2 sunucusunda, JPA / Hibernate katmanının ihtiyaç duyduğu Hibernate kütüphaneleri bulunmayabilir. Öğreticinin ilerleyen bölümlerinde, Glassfish’in size bir JPA / Hibernate uygulaması sunmadığını fark ederseniz veya hizmetleri devreye alırken Hibernate kütüphanelerinin bulunamadığını belirten bir istisna ile karşılaşırsanız, kütüphaneleri [<glassfish>/domains/domain1/lib/ext] klasörüne eklemeniz ve ardından Glassfish sunucusunu yeniden başlatmanız gerekir:

[1]'te, <glassfish>/.../lib/ext [2] klasörüne, Hibernate kütüphaneleri ve birkaç JDBC sürücüsü [3]'e, MySQL'teki JDBC sürücüsünü

Hibernate kütüphaneleri, öğreticiyle birlikte gelen zip dosyasında bulunmaktadır.

4.5. NetBeans'in otomatik kod oluşturma araçları

Şimdi inşa etmemiz gereken mimariye geri dönelim:

NetBeans ile, oluşturulan JPA varlıklarına erişimi kontrol eden [JPA] katmanını ve [Ejb] katmanını otomatik olarak oluşturmak mümkündür. Bu otomatik oluşturma yöntemlerini bilmek önemlidir, çünkü oluşturulan kod, JPA varlıklarının veya bunları kullanan EJB kodunun nasıl yazılacağına dair değerli ipuçları verir.

Şimdi bu otomatik oluşturma araçlarından bazılarını açıklayacağız. Oluşturulan kodu anlamak için, JPA, [ref1] ve EJB, [ref2] varlıklarına ilişkin iyi bir bilgiye sahip olmak gerekir.

NetBeans'te veritabanına bağlantı oluşturma

• SGBD ve MySQL 5'i çalıştırın, böylece BD kullanılabilir hale gelir
• [dbrdvmedecins] veritabanına bir NetBeans bağlantısı oluşturun

• [Files] sekmesinde, [Databases] [1] dalında, Jdbc sürücüsünü seçin: MySQL [2]
• ardından [3] "Connect Using" seçeneğini seçin; bu, MySQL
• [4]'te, istenen bilgileri girin
• ardından [5]'te onaylayın

• [6]'te bağlantı kurulur. Burada, bağlanılan veritabanındaki dört tablo görüntülenir.

Bir EJB projesi oluşturma

• [1]'te yeni bir uygulama ve bir EJB modülü oluşturun
• [2]'te, kategoriyi [Java EE] olarak seçin ve [3]'te türü [EJB Module]

• [4]'te proje için bir klasör seçin ve [5]'te projeye bir ad verin - ardından sihirbazı tamamlayın
• [6]'te oluşturulan proje

Glassfish sunucusuna bir kaynak JDBC ekleme

Glassfish sunucusuna bir kaynak ekleyeceğiz.

• [Services] sekmesinde, Glassfish sunucusunu başlatın [2, 3]
• [Projects] sekmesinde, Ejb projesine sağ tıklayın ve [5]'te projeye bir öğe eklemenizi sağlayan seçeneği seçin.

• [6]'te, [Glassfish] kategorisini seçin ve [7]'te JDBC türünü seçerek bir kaynak oluşturmak istediğinizi belirtin
• [8]'te, bu JDBC kaynağının kendi bağlantı havuzunu kullanacağını belirtin
• [9]'te, JDBC kaynağına bir ad verin
• [10]'te, bir sonraki adıma geçin

• [11]'te, JDBC kaynağının bağlantı havuzunun özellikleri tanımlanır
• [12]'te, bağlantı havuzuna bir ad verin
• [13]'te, daha önce oluşturulan NetBeans bağlantısını seçin [dbrdvmedecins]
• [14]'te, bir sonraki adıma geçin
• [15]'te, normalde bu sayfada değiştirilecek bir şey yoktur. MySQL [dbrdvmedecins] veritabanı bağlantısının özellikleri, daha önce oluşturulan NetBeans [dbrdvmedecins] bağlantısının özelliklerinden alınmıştır
• [16]'te, bir sonraki adıma geçin

• [17]'e dönüştürün, önerilen varsayılan değerleri koruyun
• [18]'e geçin, sihirbazı tamamlayın. Sihirbaz, içeriği aşağıdaki gibi olan [sun-resources.xml] ve [19] dosyalarını oluşturur:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE resources PUBLIC "-//Sun Microsystems, Inc.//DTD Application Server 9.0 Resource Definitions //EN" "http://www.sun.com/software/appserver/dtds/sun-resources_1_3.dtd">
<resources>
  <jdbc-resource enabled="true" jndi-name="jdbc/dbrdvmedecins" object-type="user" pool-name="dbrdvmedecinsPool">
    <description/>
  </jdbc-resource>
  <jdbc-connection-pool ...">
    <property name="URL" value="jdbc:mysql://localhost:3306/dbrdvmedecins"/>
    <property name="User" value="root"/>
    <property name="Password" value="()"/>
  </jdbc-connection-pool>
</resources>

Yukarıdaki dosya, sihirbarda girilen tüm bilgileri XML biçiminde içerir. Bu dosya, NetBeans tarafından GlassFish sunucusundan 4. satırda tanımlanan "jdbc/dbrdvmedecins" kaynağını oluşturmasını istemek için kullanılacaktır.

Kalıcılık biriminin oluşturulması

[persistence.xml] kalıcılık birimi, JPA katmanını yapılandırır: kullanılan JPA uygulamasını (Toplink, Hibernate, ...) belirtir ve bunu yapılandırır.

• [1]'te, EJB projesine sağ tıklayın ve [New / Other]'i seçin [2]'te
• [3]'te, [Persistence] kategorisini seçin, ardından [4]'te bir kalıcılık birimi oluşturmak istediğinizi belirtin JPA

• [5]'te, oluşturulan kalıcılık birimine bir ad verin
• [6]'te, [Hibernate]'i uygulama olarak seçin JPA
• [7]'te, az önce oluşturulan Glassfish kaynağı "jdbc/dbrdvmedecins" seçin
• [8]'te, JPA katmanının örneklendirilmesi sırasında veritabanında herhangi bir işlem yapılmaması gerektiğini belirtin
• sihirbazı sonlandırın
• [9]'te, sihirbaz tarafından oluşturulan [persistence.xml] dosyasını

İçeriği şöyledir:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="1.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd">
  <persistence-unit name="serveur-ejb-dao-jpa-hibernate-generePU" transaction-type="JTA">
    <provider>org.hibernate.ejb.HibernatePersistence</provider>
    <jta-data-source>jdbc/dbrdvmedecins</jta-data-source>
    <exclude-unlisted-classes>false</exclude-unlisted-classes>
    <properties/>
  </persistence-unit>
</persistence>

Yine, sihirbazda verilen bilgileri XML biçiminde alır. Bu dosya, "dbrdvmedecins" adlı MySQL5 veritabanıyla çalışmak için yetersizdir. Hibernate'e yönetilmesi gereken SGBD türünü belirtmemiz gerekiyor. Bu işlem daha sonra yapılacaktır.

JPA varlıklarının oluşturulması

• [1]'te projeye sağ tıklayın ve [2]'te [New / Other]
• [3]'te, [Persistence] kategorisini seçin, ardından [4]'te, mevcut bir veritabanından JPA varlıklarını oluşturmak istediğinizi belirtin.

• [5]'te, daha önce oluşturduğumuz JDBC "jdbc/dbrdvmedecins" kaynağını seçin
• [6]'e, ilişkili veritabanındaki dört tabloyu
• [7,8]'te, hepsini JPA varlıklarının oluşturulmasına dahil edin
• [9]'te, sihirbazı devam ettirin

• [10]'te, oluşturulacak JPA varlıklarını
• [11] olarak, JPA varlıklarının paketine bir ad verin
• [12]'te, JPA katmanı tarafından döndürülen nesne listelerini kapsülleyecek Java türünü seçin
• sihirbazı tamamlayın
• [13]'te, veritabanındaki her tablo için birer tane olmak üzere oluşturulan dört JPA varlığı.

Örneğin, [dbrdvmedecins] veritabanındaki [rv] tablosunun bir satırını temsil eden [Rv] varlığının kodu aşağıdadır.

package jpa;
...
@Entity
@Table(name = "rv")
public class Rv implements Serializable {
  private static final long serialVersionUID = 1L;
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  @Basic(optional = false)
  @Column(name = "ID")
  private Long id;
  @Basic(optional = false)
  @Column(name = "JOUR")
  @Temporal(TemporalType.DATE)
  private Date jour;
  @JoinColumn(name = "ID_CRENEAU", referencedColumnName = "ID")
  @ManyToOne(optional = false)
  private Creneaux idCreneau;
  @JoinColumn(name = "ID_CLIENT", referencedColumnName = "ID")
  @ManyToOne(optional = false)
  private Clients idClient;

  public Rv() {
  }

...
}

JPA varlıklarına erişim için EJB katmanının oluşturulması

• [1]'te projeye sağ tıklayın ve [2]'te [New / Other]
• [3]'te, [Persistence] kategorisini seçin, ardından [4]'te [Session Beans for Entity Classes] türünü seçin

• [5]'te, daha önce oluşturulan JPA varlıklarının listesi
• [6]'te, hepsini seçin
• [7]'te, bunlar seçildi
• [8]'te, sihirbazı devam ettirin

• [9]'te, oluşturulacak EJB paketine bir ad verin
• [10]'te, EJB'lerin hem yerel hem de uzak bir arayüzü uygulaması gerektiğini belirtin
• sihirbazı sonlandırın
• [11]'te, oluşturulan EJB'ler

İşte örneğin, [Rv] varlığına, yani [dbrdvmedecins] veritabanındaki [rv] tablosuna erişimi yöneten EJB'nin kodu:

package ejb;
...
@Stateless
public class RvFacade implements RvFacadeLocal, RvFacadeRemote {
  @PersistenceContext
  private EntityManager em;

  public void create(Rv rv) {
    em.persist(rv);
  }

  public void edit(Rv rv) {
    em.merge(rv);
  }

  public void remove(Rv rv) {
    em.remove(em.merge(rv));
  }

  public Rv find(Object id) {
    return em.find(Rv.class, id);
  }

  public List<Rv> findAll() {
    return em.createQuery("select object(o) from Rv as o").getResultList();
  }

}

Daha önce de belirtildiği gibi, otomatik kod üretimi bir projeye başlamak ve JPA ile EJB varlıklarını öğrenmek için çok yararlı olabilir. Bundan sonra, JPA ve EJB katmanlarını kendi kodumuzla yeniden yazacağız, ancak okuyucu burada az önce katmanların otomatik oluşturulmasında gördüğümüz bilgileri bulacaktır.

4.6. EJB modülünün NetBeans projesi

Yeni bir boş EJB modülü oluşturuyoruz (bkz. paragraf 4.5):

• [rdvmedecins.entites] paketi, JPA katmanının varlıklarını içerir
• [rdvmedecins.dao] paketi, [dao] katmanının EJB'sini uygular
• [rdvmedecins.exceptions] paketi, uygulamaya özgü bir istisna sınıfını uygular

Bundan sonra, okuyucunun 4.5. paragrafındaki tüm adımları uyguladığını varsayıyoruz. Okuyucunun bazı adımları tekrarlaması gerekecektir.

4.6.1. JPA katmanının yapılandırılması

İstemci/sunucu uygulamamızın mimarisini hatırlayalım:

NetBeans projesi:

[JPA] katmanı, yukarıdaki [persistence.xml] ve [sun-resources.xml] dosyaları ile yapılandırılır. Bu iki dosya, daha önce karşılaştığımız sihirbazlar tarafından oluşturulur:

• [sun-resources.xml] dosyasının oluşturulması 4.5. paragrafta açıklanmıştır.
• [persistence.xml] dosyasının oluşturulması 4.5. paragrafta açıklanmıştır.

Oluşturulan [persistence.xml] dosyası aşağıdaki şekilde değiştirilmelidir:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="1.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd">
  <persistence-unit name="dbrdvmedecins" transaction-type="JTA">
    <provider>org.hibernate.ejb.HibernatePersistence</provider>
    <jta-data-source>jdbc/dbrdvmedecins</jta-data-source>
    <properties>
       <!-- Lehçe -->
      <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5InnoDBDialect"/>
    </properties>
  </persistence-unit>
</persistence>

• 3. satır: işlem türü JTA'tir: işlemler Glassfish'in Ejb3 konteyneri tarafından yönetilecektir
• 4. satır: Bir JPA / Hibernate uygulaması kullanılmaktadır. Bunun için Hibernate kütüphanesi GlassFish sunucusuna eklenmiştir (bkz. paragraf 4.4).
• 5. satır: JPA katmanı tarafından kullanılan JTA veri kaynağının adı JNDI “jdbc/dbrdvmedecins”’dir.
• 8. satır: Bu satır otomatik olarak oluşturulmaz. Elle eklenmesi gerekir. Bu satır, Hibernate’e kullanılan SGBD’in aslında MySQL5 olduğunu belirtir.

"jdbc/dbrdvmedecins" veri kaynağı, aşağıdaki [sun-resources.xml] dosyasında yapılandırılmıştır:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE resources PUBLIC "-//Sun Microsystems, Inc.//DTD Application Server 9.0 Resource Definitions //EN" "http://www.sun.com/software/appserver/dtds/sun-resources_1_3.dtd">
<resources>
  <jdbc-resource enabled="true" jndi-name="jdbc/dbrdvmedecins" object-type="user" pool-name="dbrdvmedecinsPool">
    <description/>
  </jdbc-resource>
  <jdbc-connection-pool ...>
    <property name="URL" value="jdbc:mysql://localhost/dbrdvmedecins"/>
    <property name="User" value="root"/>
    <property name="Password" value="()"/>
  </jdbc-connection-pool>
</resources>

• 8-10. satırlar: Veri kaynağının JDBC özellikleri (veritabanı URL'si, kullanıcı adı ve şifre). MySQL dbrdvmedecins veritabanı, 4.1. paragrafta açıklanan veritabanıdır.
• 7. satır: Bu veri kaynağına ilişkin bağlantı havuzunun özellikleri

4.6.2. JPA katmanındaki varlıklar

İstemci/sunucu uygulamamızın mimarisini hatırlayalım:

NetBeans projesi:

[rdvmedecins.entites] paketi, [Jpa] katmanını uygular.

4.5. paragrafta, bir uygulamanın JPA varlıklarını nasıl otomatik olarak oluşturacağımızı görmüştük. Burada bu tekniği kullanmayacağız, ancak varlıkları kendimiz tanımlayacağız. Bununla birlikte, bu varlıklar 4.5. paragrafta oluşturulan kodun büyük bir kısmını içerecektir. Burada, [Medecin] ve [Client] varlıklarının, [Personne] sınıfının alt sınıfları olmasını istiyoruz.

Personne sınıfı, doktorları ve müşterileri temsil etmek için kullanılır:

package rdvmedecins.entites;
...
@MappedSuperclass
public class Personne implements Serializable {
   // bir kişinin özellikleri

  @Id
  @GeneratedValue(strategy = GenerationType.AUTO)
  @Column(name = "ID")
  private Long id;
  @Version
  @Column(name = "VERSION", nullable = false)
  private Integer version;

  @Column(name = "TITRE", length = 5, nullable = false)
  private String titre;
  @Column(name = "NOM", length = 30, nullable = false)
  private String nom;
  @Column(name = "PRENOM", length = 30, nullable = false)
  private String prenom;

   // varsayılan oluşturucu
  public Personne() {
  }

   // parametreli oluşturucu
  public Personne(String titre, String nom, String prenom) {
     // setter'lar aracılığıyla
...
  }

   // kopyalama yoluyla oluşturucu
  public Personne(Personne personne) {
     // setter'lar aracılığıyla
 ...
  }

   // toString
  @Override
  public String toString() {
    return "[" + titre + "," + prenom + "," + nom + "]";
  }

// alıcı ve ayarlayıcılar
....
}

• 3. satır: [Personne] sınıfının kendisinin bir varlık (@Entity) olmadığına dikkat edilmelidir. Bu sınıf, varlıkların üst sınıfı olacaktır. @MappedSuperClass anotasyonu bu durumu belirtir.

[Client] varlığı, [clients] tablosundaki satırları kapsüller. Bu varlık, önceki [Personne] sınıfından türetilmiştir:

package rdvmedecins.entites;
....
@Entity
@Table(name = "CLIENTS")
public class Client extends Personne implements Serializable {

   // varsayılan oluşturucu
  public Client() {
  }

   // parametreli oluşturucu
  public Client(String titre, String nom, String prenom) {
     // üst sınıf
    super(titre, nom, prenom);
  }

   // kopyalama yoluyla oluşturucu
  public Client(Client client) {
     // üst sınıf
    super(client);
  }
}

• 3. satır: [Client] sınıfı bir JPA varlığıdır
• 4. satır: [clients] tablosuyla ilişkilidir
• 5. satır: [Personne] sınıfından türetilmiştir

[medecins] tablosunun satırlarını kapsayan [Medecin] varlığı da aynı modeli izler:

package rdvmedecins.entites;
...
@Entity
@Table(name = "MEDECINS")
public class Medecin extends Personne implements Serializable {

   // varsayılan oluşturucu
  public Medecin() {
  }

   // parametreli oluşturucu
  public Medecin(String titre, String nom, String prenom) {
     // üst sınıf
    super(titre, nom, prenom);
  }

   // kopyalama yoluyla oluşturucu
  public Medecin(Medecin medecin) {
     // üst nesne
    super(medecin);
  }
}

[Creneau] varlığı, [creneaux] tablosunun satırlarını kapsar:

package rdvmedecins.entites;
....
@Entity
@Table(name = "CRENEAUX")
public class Creneau implements Serializable {

   // RV zaman aralığının özellikleri
  @Id
  @GeneratedValue(strategy = GenerationType.AUTO)
  @Column(name = "ID")
  private Long id;
  @Version
  @Column(name = "VERSION", nullable = false)
  private Integer version;
  @ManyToOne
  @JoinColumn(name = "ID_MEDECIN", nullable = false)
  private Medecin medecin;
  @Column(name = "HDEBUT", nullable = false)
  private Integer hdebut;
  @Column(name = "MDEBUT", nullable = false)
  private Integer mdebut;
  @Column(name = "HFIN", nullable = false)
  private Integer hfin;
  @Column(name = "MFIN", nullable = false)
  private Integer mfin;

   // varsayılan üretici
  public Creneau() {

  }

   // parametreli oluşturucu
  public Creneau(Medecin medecin, Integer hDebut,Integer mDebut, Integer hFin, Integer mFin) {
     // setter'lar aracılığıyla
...
  }

   // kopyalama yoluyla oluşturucu
  public Creneau(Creneau creneau) {
     // setter'lar aracılığıyla
...
  }

   // toString
  @Override
  public String toString() {
    return "[" + getId() + "," + getVersion() + "," + getMedecin() + "," + getHdebut() + ":" + getMdebut() + "," + getHfin() + ":" + getMfin() + "]";
  }

   // setter'lar - getter'lar
...
}

• 15-17. satırlar, veritabanındaki [creneaux] tablosu ile [medecins] tablosu arasında bulunan "bir-çok" ilişkisini modellemektedir.

[Rv] varlığı, [rv] tablosundaki satırları kapsar:

package rdvmedecins.entites;
...
@Entity
@Table(name = "RV")
public class Rv implements Serializable {
   // özellikler

  @Id
  @GeneratedValue(strategy = GenerationType.AUTO)
  @Column(name = "ID")
  private Long id;
  @Column(name = "JOUR", nullable = false)
  @Temporal(TemporalType.DATE)
  private Date jour;
  @ManyToOne
  @JoinColumn(name = "ID_CLIENT", nullable = false)
  private Client client;
  @ManyToOne
  @JoinColumn(name = "ID_CRENEAU", nullable = false)
  private Creneau creneau;

   // varsayılan oluşturucu
  public Rv() {
  }

   // parametreli oluşturucu
  public Rv(Date jour, Client client, Creneau creneau) {
     // setter'lar aracılığıyla
...
  }

   // kopyalama yoluyla oluşturucu
  public Rv(Rv rv) {
     // setter'lar aracılığıyla
...
  }

   // toString
  @Override
  public String toString() {
    return "[" + getId() + "," + new SimpleDateFormat("dd/MM/yyyy").format(getJour()) + "," + getClient() + "," + getCreneau() + "]";
  }

// alıcı ve ayarlayıcılar
...
}

• 15-17. satırlar, veritabanındaki [rv] tablosu ile [clients] tablosu arasında bulunan "bir-çok" ilişkisini, 18-20. satırlar ise "bir-çok" ilişkisini modellemektedir

4.6.3. İstisna sınıfı

Uygulamadaki [RdvMedecinsException] istisna sınıfı şu şekildedir:

package rdvmedecins.exceptions;

import javax.ejb.ApplicationException;

@ApplicationException(rollback=true)
public class RdvMedecinsException extends RuntimeException {

  private static final long serialVersionUID = 1L;

   // özel alanlar
  private int code = 0;

   // yapıcılar
  public RdvMedecinsException() {
    super();
  }

  public RdvMedecinsException(String message) {
    super(message);
  }

  public RdvMedecinsException(String message, Throwable cause) {
    super(message, cause);
  }

  public RdvMedecinsException(Throwable cause) {
    super(cause);
  }

  public RdvMedecinsException(String message, int code) {
    super(message);
    setCode(code);
  }

  public RdvMedecinsException(Throwable cause, int code) {
    super(cause);
    setCode(code);
  }

  public RdvMedecinsException(String message, Throwable cause, int code) {
    super(message, cause);
    setCode(code);
  }

   // getter'lar - setter'lar
...
}

• 6. satır: Sınıf, [RuntimeException] sınıfından türetilmiştir. Dolayısıyla derleyici, bu istisnayı try / catch ile yönetmeyi zorunlu kılmaz.
• 5. satır: @ApplicationException anotasyonu, istisnanın [EjbException] türündeki bir istisna tarafından "yutulmamasını" sağlar.

@ApplicationException anotasyonunu anlamak için sunucu tarafında kullanılan mimariye geri dönelim:

[RdvMedecinsException] türündeki istisna, Ejb3 kapsayıcısı içindeki [dao] katmanına ait EJB yöntemleri tarafından tetiklenecek ve bu kapsayıcı tarafından yakalanacaktır. @ApplicationException anotasyonu olmadan, Ejb3 konteyneri meydana gelen istisnayı [EjbException] türünde bir istisna içinde kapsüller ve bunu yeniden atar. Bu kapsüllemeyi istemediğinizde, Ejb3 konteynerinden [RdvMedecinsException] türünde bir istisnanın dışarı çıkmasına izin verebilirsiniz. @ApplicationException anotasyonu bunu sağlar. Ayrıca, bu anotasyonun (rollback=true) özniteliği, EJB3 konteynerine, SGBD ile bir işlem kapsamında yürütülen bir yöntem içinde [RdvMedecinsException] türünde bir istisna meydana gelirse, işlemin geri alınması gerektiğini bildirir. Teknik terimlerle ifade etmek gerekirse, buna işlemin rollback'i yapılması denir.

4.6.4. [dao] katmanındaki EJB

[dao] katmanındaki java arayüzü [IDao] şu şekildedir:

package rdvmedecins.dao;
...
public interface IDao {

   // müşteri listesi
  public List<Client> getAllClients();
   // doktor listesi
  public List<Medecin> getAllMedecins();
   // bir doktorun randevu aralıkları listesi
  public List<Creneau> getAllCreneaux(Medecin medecin);
   // belirli bir günde bir doktorun randevu listesi
  public List<Rv> getRvMedecinJour(Medecin medecin, String jour);
   // kimlik numarasıyla bir müşteriyi bulma
  public Client getClientById(Long id);
   // kimlik numarasıyla bir müşteriyi bulma
  public Medecin getMedecinById(Long id);
   // ID'siyle tanımlanan bir randevuyu bulma
  public Rv getRvById(Long id);
   // ID'siyle tanımlanan bir zaman aralığını bulma
  public Creneau getCreneauById(Long id);
   // bir RV eklemek
  public Rv ajouterRv(String jour, Creneau creneau, Client client);
   // RV'i sil
  public void supprimerRv(Rv rv);
}

EJB'nin yerel arayüzü [IDaoLocal], önceki [IDao] arayüzünden türetilmiştir:

package rdvmedecins.dao;

import javax.ejb.Local;

@Local
public interface IDaoLocal extends IDao{
}

Aynı durum, uzaktaki [IDaoRemote] arayüzü için de geçerlidir:

package rdvmedecins.dao;

import javax.ejb.Remote;

@Remote
public interface IDaoRemote extends IDao {
}

[DaoJpa] EJB'si, hem yerel hem de uzak arayüzleri uygular:

package rdvmedecins.dao;
...
@Stateless(mappedName="rdvmedecins.dao")
@TransactionAttribute(TransactionAttributeType.REQUIRED)
public class DaoJpa implements IDaoLocal,IDaoRemote {
...
}

• 3. satır, uzak EJB'nin adının "rdvmedecins.dao" olduğunu gösterir
• 4. satır, EJB'nin tüm yöntemlerinin EJB3 konteyneri tarafından yönetilen bir işlem içinde gerçekleştirildiğini gösterir.
• 5. satır, EJB'nin yerel ve uzak arayüzleri uyguladığını gösterir.

EJB'nin tam kodu şöyledir:

package rdvmedecins.dao;
...
@Stateless(mappedName="rdvmedecins.dao")
@TransactionAttribute(TransactionAttributeType.REQUIRED)
public class DaoJpa implements IDaoLocal,IDaoRemote {

  @PersistenceContext
  private EntityManager em;

   // müşteri listesi
  public List<Client> getAllClients() {
    try {
      return em.createQuery("select c from Client c").getResultList();
    } catch (Throwable th) {
      throw new RdvMedecinsException(th, 1);
    }
  }

   // doktor listesi
  public List<Medecin> getAllMedecins() {
    try {
      return em.createQuery("select m from Medecin m").getResultList();
    } catch (Throwable th) {
      throw new RdvMedecinsException(th, 2);
    }
  }

   // belirli bir doktorun randevu saatleri listesi
   // doktor: doktor
  public List<Creneau> getAllCreneaux(Medecin medecin) {
    try {
      return em.createQuery("select c from Creneau c join c.medecin m where m.id=:idMedecin").setParameter("idMedecin", medecin.getId()).getResultList();
    } catch (Throwable th) {
      throw new RdvMedecinsException(th, 3);
    }
  }

   // belirli bir doktorun belirli bir günkü randevu listesi
   // doktor: doktor
   // gün: gün
  public List<Rv> getRvMedecinJour(Medecin medecin, String jour) {
    try {
      return em.createQuery("select rv from Rv rv join rv.creneau c join c.medecin m where m.id=:idMedecin and rv.jour=:jour").setParameter("idMedecin", medecin.getId()).setParameter("jour", new SimpleDateFormat("yyyy:MM:dd").parse(jour)).getResultList();
    } catch (Throwable th) {
      throw new RdvMedecinsException(th, 4);
    }
  }

   // randevu eklenmesi
   // gün: randevunun yapıldığı gün
   // zaman aralığı: randevunun zaman aralığı
   // müşteri: randevu alınan müşteri
  public Rv ajouterRv(String jour, Creneau creneau, Client client) {
    try {
      Rv rv = new Rv(new SimpleDateFormat("yyyy:MM:dd").parse(jour), client, creneau);
      em.persist(rv);
      return rv;
    } catch (Throwable th) {
      throw new RdvMedecinsException(th, 5);
    }
  }

   // Randevu silme
   // randevu: silinen randevu
  public void supprimerRv(Rv rv) {
    try {
      em.remove(em.merge(rv));
    } catch (Throwable th) {
      throw new RdvMedecinsException(th, 6);
    }
  }

   // belirli bir müşteriyi bulma
  public Client getClientById(Long id) {
    try {
      return (Client) em.find(Client.class, id);
    } catch (Throwable th) {
      throw new RdvMedecinsException(th, 7);
    }
  }

   // belirli bir doktoru bulma
  public Medecin getMedecinById(Long id) {
    try {
      return (Medecin) em.find(Medecin.class, id);
    } catch (Throwable th) {
      throw new RdvMedecinsException(th, 8);
    }
  }

   // belirli bir randevuyu bulma
  public Rv getRvById(Long id) {
    try {
      return (Rv) em.find(Rv.class, id);
    } catch (Throwable th) {
      throw new RdvMedecinsException(th, 9);
    }
  }

   // belirli bir randevu aralığını bul
  public Creneau getCreneauById(Long id) {
    try {
      return (Creneau) em.find(Creneau.class, id);
    } catch (Throwable th) {
      throw new RdvMedecinsException(th, 10);
    }
  }
}

• 8. satır: Kalıcılık bağlamına erişimi yöneten EntityManager nesnesi. Sınıfın örneklendirilmesi sırasında, bu alan 7. satırdaki @PersistenceContext ek açıklaması sayesinde EJB konteyneri tarafından başlatılacaktır.
• 15. satır: JPQL sorgusu, [clients] tablosundaki tüm satırları bir [Client] nesneleri listesi biçiminde döndürür.
• 22. satır: Doktorlar için benzer bir sorgu
• 32. satır: [creneaux] ve [medecins] tabloları arasında bir birleştirme gerçekleştiren JPQL sorgusu. Bu sorgu, doktorun kimliği ile parametrelendirilmiştir.
• 43. satır: [rv], [creneaux] ve [medecins] tabloları arasında bir birleştirme gerçekleştiren ve iki parametreye sahip olan JPQL sorgusu: doktorun kimliği ve randevu günü.
• 55-57. satırlar: Bir randevunun oluşturulması ve ardından veritabanına kaydedilmesi.
• 67. satır: Veritabanındaki bir randevunun silinmesi.
• 76. satır: Belirli bir müşteriyi bulmak için veritabanında bir select sorgusu gerçekleştirir
• 85. satır: Bir doktor için de aynısı geçerlidir
• 94. satır: Randevu için de aynısı
• 103. satır: Bir zaman aralığı için de aynısı geçerlidir.
• 9. satırdaki em kalıcılık bağlamıyla yapılan tüm işlemlerde veritabanıyla ilgili bir sorun yaşanabilir. Bu nedenle hepsi bir try / catch bloğu içine alınmıştır. Olası istisna, "özel" RdvMedecinsException istisnası içinde kapsüllenmiştir.

EJB modülü derlendiğinde, adlı bir .jar dosyası oluşturulur:

4.7. NetBeans ile [dao] katmanındaki EJB'nin dağıtımı

NetBeans, daha önce oluşturulan EJB'yi GlassFish sunucusuna kolayca dağıtmanıza olanak tanır.

• EJB projesinin özelliklerinde, [1] yürütme seçeneklerini kontrol edin.
• [2]'te, EJB'nin dağıtılacağı sunucunun adı
• [Services] sekmesinde [3], [4]'i başlatın.

• [5]'te, Glassfish sunucusu başlatıldıktan sonra. Henüz bir EJB modülü yok.

• MySQL sunucusunu başlatın ve [dbrdvmedecins] veritabanının çevrimiçi olduğundan emin olun. Bunun için 4.5. paragrafta oluşturulan NetBeans bağlantısını kullanabilirsiniz.

• [Projects] [6] sekmesinde, [7] EJB modülünü dağıtın: EJB tarafından kullanılan "jdbc/dbrdvmedecins" adlı JDBC kaynağına erişilebilmesi için SGBD ve MySQL5'in başlatılmış olması gerekir.
• [8]'te, dağıtılan EJB, GlassFish sunucusunun dizin yapısında görünür

• [9]'te, dağıtılmış EJB kaldırılır
• [10]'te, EJB artık Glassfish sunucusunun dizin yapısında görünmüyor.

4.8. [dao] katmanındaki EJB'nin GlassFish ile dağıtımı

Burada, bir EJB'yi .jar arşivinden GlassFish sunucusuna nasıl dağıtacağımızı göstereceğiz.

• MySQL sunucusunu başlatın ve [dbrdvmedecins] veritabanının çevrimiçi olduğundan emin olun. Bunun için 4.5. paragrafta oluşturulan NetBeans bağlantısını kullanabilirsiniz.

Dağıtılacak EJB modülünün JPA yapılandırmasını hatırlayalım. Bu yapılandırma, [persistence.xml] dosyasında yapılır:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="1.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd">
  <persistence-unit name="dbrdvmedecins" transaction-type="JTA">
    <provider>org.hibernate.ejb.HibernatePersistence</provider>
    <jta-data-source>jdbc/dbrdvmedecins</jta-data-source>
    <properties>
       <!-- Lehçe -->
      <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5InnoDBDialect"/>
    </properties>
  </persistence-unit>
</persistence>

1. satır, Jpa katmanının "jdbc/dbrdvmedecins" adlı Ejb3 konteyneri tarafından yönetilen JTA ve c.a.d veri kaynaklarını kullandığını gösterir.

4.5. paragrafta, bu JDBC kaynağını NetBeans'ten nasıl oluşturacağımızı görmüştük. Burada ise bunu doğrudan GlassFish ile nasıl yapacağımızı göstereceğiz. Burada, [ref1] kitabının 13.1.2. paragrafında, 79. sayfada açıklanan prosedürü takip ediyoruz.

Kaynağı yeniden oluşturabilmek için önce onu siliyoruz. Bunu NetBeans üzerinden yapıyoruz:

• [1]'te, Glassfish sunucusundaki JDBC kaynakları
• [2] olarak, EJB'mizdeki "jdbc/dbrdvmedecins" kaynağını
• [3]'e, bu kaynağın bağlantı havuzu JDBC

• [4]'te, bağlantı havuzu silinir. Bu işlem, onu kullanan tüm JDBC kaynaklarını, dolayısıyla "jdbc/dbrdvmedecins" kaynağını da silecektir.
• [5] ve [6]'te, JDBC kaynağı ve bağlantı havuzu silinmiştir.

Şimdi, Glassfish sunucusunun yönetim konsolunu kullanarak JDBC kaynağını oluşturuyor ve EJB'yi dağıtıyoruz.

• NetBeans'teki [services] [1] sekmesinde, GlassFish sunucusunu [2] başlatın ve ardından yönetim konsoluna [3] erişin
• [4] adresinde, yönetici olarak oturum açın (şifre: adminadmin; kurulum sırasında veya sonrasında şifreyi değiştirmediyseniz).

• [5]'te, Glassfish kaynakları içindeki [Connection Pools] dalını seçin
• [6]'te yeni bir bağlantı havuzu oluşturun. Hatırlatmak gerekirse, bağlantı havuzu, bir SGBD ile bağlantı açma/kapama sayısını sınırlamak için kullanılan bir tekniktir. Sunucu başlatıldığında, yapılandırmada tanımlanan sayı kadar (N) SGBD ile bağlantı açılır. Bu açık bağlantılar daha sonra, SGBD ile bir işlem gerçekleştirmek için talep eden EJB'lerin kullanımına sunulur. İşlem tamamlanır tamamlanmaz, EJB bağlantıyı havuza geri verir. Bağlantı hiçbir zaman kapatılmaz. SGBD'e erişen farklı iş parçacıkları arasında paylaşılır
• [7]'e erişen farklı iş parçacıkları arasında paylaşılır; havuza bir ad verin
• [8] olarak adlandırın; veri kaynağını modelleyen sınıf [javax.sql.DataSource]
• [9]'te, veri kaynağını barındıran SGBD burada MySQl'tir.
• [10]'te bir sonraki adıma geçin

• [11]'te, "Connection Validation Required" özniteliği, bir bağlantı verilmeden önce havuzun bağlantının çalışır durumda olup olmadığını kontrol etmesini sağlar. Çalışır durumda değilse, yeni bir bağlantı oluşturur. Bu, SGBD ile geçici bir kesinti sonrasında uygulamanın çalışmaya devam etmesini sağlar. Kesinti süresince hiçbir bağlantı kullanılamaz ve istemciye istisnalar bildirilir. Kesinti sona erdiğinde, bağlantı talep etmeye devam eden istemciler yeniden bağlantı alırlar: "Connection Validation Required" özniteliği sayesinde havuzdaki tüm bağlantılar yeniden oluşturulur. Bu öznitelik olmasaydı, havuz ilk bağlantıların kesildiğini fark ederdi ancak yeni bağlantılar oluşturmaya çalışmazdı.
• [12]'te, işlemler için "Read Committed" yalıtım düzeyi talep edilmektedir. Bu düzey, T2 işlemlerinin, T1 işlemi tamamen tamamlanana kadar bu işlem tarafından değiştirilen verileri okuyamayacağını garanti eder.
• [13]'te, tüm işlemlerin [12]'te belirtilen yalıtım düzeyini kullanması talep edilmektedir.

• [14] ve [15]'te, bağlantı havuzunu yöneten BD'in URL'sini belirtin
• [16]'te, kullanıcı root olacaktır
• [17]'te bir özellik ekleyin
• [18]'te, değeri () olan "Password" özelliğini ekleyin [19]'te. [19] ekran görüntüsünde gösterilmese de, boş bir şifre belirtmek için dizeyi boş bırakmamalı, () (açılış parantezi, kapanış parantezi) yazmalısınız. SGBD MySQL'teki root kullanıcısının boş olmayan bir parolası varsa, bu parolayı girin.
• [20]'te, MySQL [dbrdvmedecins] veritabanı için bağlantı havuzu oluşturma sihirbazını tamamlayın.

• [21]'te, havuz oluşturulmuştur. Bağlantısına tıklayın.
• [22]'te, [Ping] düğmesi, [dbrdvmedecins] veritabanıyla bağlantı kurmanıza olanak tanır
• [23]'te, her şey yolunda giderse, bağlantının başarılı olduğunu belirten bir mesaj görüntülenir

Bağlantı havuzu oluşturulduktan sonra bir JDBC kaynağı oluşturabilirsiniz:

• [1]'te, sunucu nesne ağacından [JDBC Resources] dalını seçin
• [2]'te, JDBC adlı yeni bir kaynak oluşturulur
• [3]'te, JDBC kaynağına bir ad verilir. Bu ad, [persistence.xml] dosyasında kullanılan adla aynı olmalıdır:

    <jta-data-source>jdbc/dbrdvmedecins</jta-data-source>

• [4]'te, yeni JDBC kaynağının kullanması gereken bağlantı havuzu belirtilir: az önce oluşturulan havuz
• [5] dosyasında, oluşturma sihirbazını tamamlayın

• [6]'te yeni kaynak JDBC

Artık JDBC kaynağı oluşturulduğuna göre, EJB'nin jar arşivini dağıtabiliriz:

• [1]'e, [Enterprise Applications] dalını seçin
• [2]'e, [Deploy] düğmesini kullanarak yeni bir uygulama dağıtmak istediğinizi belirtin
• [3]'te, uygulamanın bir EJB modülü olduğunu belirtin
• [4]'te, TP için size verilmiş olan [serveur-ejb-dao-jpa-hibernate.jar] EJB'sinin JAR dosyasını seçin.
• [5] adımında, isterseniz EJB modülünün adını değiştirebilirsiniz
• [6]'te, EJB modülünün dağıtım sihirbazını tamamlayın

• [7]'te Ejb modülü devreye alınmıştır. Artık kullanılabilir.

4.9. [dao] katmanındaki EJB'nin test edilmesi

Uygulamamızın [dao] katmanındaki EJB artık dağıtıldığına göre, bunu test edebiliriz. Bunu aşağıdaki Java istemcisi aracılığıyla yapacağız:

[MainTestsDaoRemote] [1] sınıfı, bir test sınıfıdır JUnit 4. [2] kütüphaneleri bir yandan şunlardan oluşur:

• [dao] [3] katmanının EJB jar dosyası (bkz. paragraf 4.6.4).
• EJB'lerin uzak istemcileri için gerekli olan GlassFish kütüphaneleri [4].

Test sınıfı şöyledir:

package dao;
...
public class MainTestsDaoRemote {

   // [dao] katmanı test edildi
  private static IDaoRemote dao;

  @BeforeClass
  public static void init() throws NamingException {
     // ortamın başlatılması JNDI
    InitialContext initialContext = new InitialContext();
     // DAO katmanının örneklenmesi
    dao = (IDaoRemote) initialContext.lookup("rdvmedecins.dao");
  }

  @Test
  public void test1() {
     // test verileri
    String jour = "2006:08:23";
     // müşterilerin görüntülenmesi
    List<Client> clients = null;
    try {
      clients = dao.getAllClients();
      display("Liste des clients :", clients);
    } catch (Exception ex) {
      System.out.println(ex);
    }
     // doktorların görüntülenmesi
    List<Medecin> medecins = null;
    try {
      medecins = dao.getAllMedecins();
      display("Liste des médecins :", medecins);
    } catch (Exception ex) {
      System.out.println(ex);
    }
     // bir doktorun randevu aralıklarının görüntülenmesi
    Medecin medecin = medecins.get(0);
    List<Creneau> creneaux = null;
    try {
      creneaux = dao.getAllCreneaux(medecin);
      display(String.format("Liste des créneaux du médecin %s", medecin), creneaux);
    } catch (Exception ex) {
      System.out.println(ex);
    }
     // belirli bir günde bir doktorun randevu listesi
    try {
      display(String.format("Liste des créneaux du médecin %s, le [%s]", medecin, jour), dao.getRvMedecinJour(medecin, jour));
    } catch (Exception ex) {
      System.out.println(ex);
    }
     // bir RV ekle
    Rv rv = null;
    Creneau creneau = creneaux.get(2);
    Client client = clients.get(0);
    System.out.println(String.format("Ajout d'un Rv le [%s] dans le créneau %s pour le client %s", jour, creneau, client));
    try {
      rv = dao.ajouterRv(jour, creneau, client);
      System.out.println("Rv ajouté");
      display(String.format("Liste des Rv du médecin %s, le [%s]", medecin, jour), dao.getRvMedecinJour(medecin, "2006:08:23"));
    } catch (Exception ex) {
      System.out.println(ex);
    }
     // aynı günün aynı randevu aralığına bir RV ekle
     // bir istisna oluşturmalıdır
    System.out.println(String.format("Ajout d'un Rv le [%s] dans le créneau %s pour le client %s", jour, creneau, client));
    try {
      rv = dao.ajouterRv(jour, creneau, client);
      System.out.println("Rv ajouté");
      display(String.format("Liste des Rv du médecin %s, le [%s]", medecin, jour), dao.getRvMedecinJour(medecin, "2006:08:23"));
    } catch (Exception ex) {
      System.out.println(ex);
    }
     // bir RV'i sil
    System.out.println("Suppression du Rv ajouté");
    try {
      dao.supprimerRv(rv);
      System.out.println("Rv supprimé");
      display(String.format("Liste des Rv du médecin %s, le [%s]", medecin, jour), dao.getRvMedecinJour(medecin, "2006:08:23"));
    } catch (Exception ex) {
      System.out.println(ex);
    }
  }

   // yardımcı yöntem - bir koleksiyondaki öğeleri görüntüler
  private static void display(String message, List elements) {
    System.out.println(message);
    for (Object element : elements) {
      System.out.println(element);
    }
  }
}

• 13. satır: Uzak EJB'nin proxy'sinin örneklendirildiğine dikkat edilmelidir. Adı JNDI "rdvmedecins.dao" kullanılır.
• Test yöntemleri, EJB tarafından sunulan yöntemleri kullanır (bkz. paragraf 4.6.4).

Her şey yolunda giderse, testler başarılı olmalıdır:

Artık [dao] katmanındaki EJB çalışır durumda olduğuna göre, bir web hizmeti aracılığıyla kamuya açılma aşamasına geçilebilir.

4.10. [dao] katmanının web hizmeti

Web hizmeti kavramına ilişkin kısa bir giriş için, [ref1] kitabının 111. sayfasındaki 14. paragrafa bakabilirsiniz.

Şimdi, istemci/sunucu uygulamamızın sunucu mimarisine geri dönelim:

Yukarıda, [dao] katmanındaki web hizmetiyle ilgileniyoruz. Bu hizmetin tek işlevi, [dao] katmanındaki EJB arayüzünü, bir web hizmetiyle iletişim kurabilen çoklu platform istemcilere sunmaktır.

Bir web hizmetini uygulamak için iki yol olduğunu hatırlayalım:

• web konteynerinde çalışan @WebService anotasyonlu bir sınıf aracılığıyla

• EJB konteynerinde çalışan ve @WebService anotasyonuyla işaretlenmiş bir EJB aracılığıyla

Burada ilk çözümü kullanıyoruz. NetBeans'te, iki modülden oluşan bir kurumsal proje oluşturmamız gerekiyor:

• EJB konteynerinde çalışacak EJB modülü: [dao] katmanındaki EJB.
• web konteynerinde çalışacak web modülü: şu anda oluşturmakta olduğumuz web hizmeti.

Bu kurumsal projeyi iki farklı şekilde oluşturacağız.

4.10.1. NetBeans Projesi - Sürüm 1

Öncelikle "Web Uygulaması" türünde bir NetBeans projesi oluşturuyoruz:

• [1]'te, "Java Web" [2] kategorisi altında "Web Uygulaması" [3] türünde yeni bir proje oluşturuyoruz.

• [4]'te projeye bir ad verilir ve [5]'te projenin oluşturulacağı klasör belirlenir
• [6]'te, web uygulamasını çalıştıracak uygulama sunucusu belirlenir
• [7]'te, uygulamanın bağlamı belirlenir
• [8] adımında, proje yapılandırmasını onaylıyoruz.

• [9]'te, oluşturulan proje. Oluşturduğumuz web hizmeti, önceki proje olan [10]'in EJB dosyasını kullanacaktır. Bu nedenle, EJB modülünün .jar dosyasını [10] referans olarak eklemesi gerekir.

• [11] projesinde, [12] web projesinin kütüphanelerine bir NetBeans projesi eklenir

• [13]'te, dosya sisteminden EJB modülünün klasörünü seçip onaylıyoruz.

• [14]'te, EJB modülü web projesinin kütüphanelerine eklenmiştir.

[15]'te, web hizmetini aşağıdaki [WsDaoJpa] sınıfıyla uyguluyoruz:

package rdvmedecins.ws;
...
@WebService()
public class WsDaoJpa implements IDao {

  @EJB
  private IDaoLocal dao;

   // müşteri listesi
  @WebMethod
  public List<Client> getAllClients() {
    return dao.getAllClients();
  }

   // doktor listesi
  @WebMethod
  public List<Medecin> getAllMedecins() {
    return dao.getAllMedecins();
  }

   // belirli bir doktorun randevu saatleri listesi
   // doktor: doktor
  @WebMethod
  public List<Creneau> getAllCreneaux(Medecin medecin) {
    return dao.getAllCreneaux(medecin);
  }

   // belirli bir doktorun belirli bir günkü randevu listesi
   // doktor: doktor
   // gün: gün
  @WebMethod
  public List<Rv> getRvMedecinJour(Medecin medecin, String jour) {
    return dao.getRvMedecinJour(medecin, jour);
  }

   // randevu eklenmesi
   // gün: randevunun yapıldığı gün
   // zaman aralığı: randevunun zaman aralığı
   // müşteri: randevu alınan müşteri
  @WebMethod
  public Rv ajouterRv(String jour, Creneau creneau, Client client) {
    return dao.ajouterRv(jour, creneau, client);
  }

   // Randevu silme
   // randevu: silinen randevu
  @WebMethod
  public void supprimerRv(Rv rv) {
    dao.supprimerRv(rv);
  }

   // belirli bir müşteriyi bulma
  @WebMethod
  public Client getClientById(Long id) {
    return dao.getClientById(id);
  }

   // belirli bir doktoru bulma
  @WebMethod
  public Medecin getMedecinById(Long id) {
    return dao.getMedecinById(id);
  }

   // belirli bir randevuyu bulma
  @WebMethod
  public Rv getRvById(Long id) {
    return dao.getRvById(id);
  }

   // belirli bir randevu aralığını bul
  @WebMethod
  public Creneau getCreneauById(Long id) {
    return dao.getCreneauById(id);
  }
}

• 4. satırda, [WsdaoJpa] sınıfı, [IDao] arayüzünü uygulamaktadır. Bu arayüzün, [dao] katmanındaki EJB arşivinde aşağıdaki şekilde tanımlandığını hatırlayalım:

package rdvmedecins.dao;
...
public interface IDao {

   // müşteri listesi
  public List<Client> getAllClients();
   // doktor listesi
  public List<Medecin> getAllMedecins();
   // bir doktorun randevu zaman aralıklarının listesi
  public List<Creneau> getAllCreneaux(Medecin medecin);
   // belirli bir günde bir doktorun randevu listesi
  public List<Rv> getRvMedecinJour(Medecin medecin, String jour);
   // kimlik numarasıyla bir müşteriyi bul
  public Client getClientById(Long id);
   // kimlik numarasıyla bir müşteriyi bulma
  public Medecin getMedecinById(Long id);
   // ID'siyle tanımlanan bir randevuyu bulma
  public Rv getRvById(Long id);
   // ID'siyle tanımlanan bir zaman aralığını bulma
  public Creneau getCreneauById(Long id);
   // bir RV eklemek
  public Rv ajouterRv(String jour, Creneau creneau, Client client);
   // RV'i silmek
  public void supprimerRv(Rv rv);
}

• 3. satır: @WebService anotasyonu, [WsDaoJpa] sınıfını bir web hizmeti haline getirir.
• 6-7. satırlar: [dao] katmanındaki EJB referansı, uygulama sunucusu tarafından 7. satırdaki alana enjekte edilecektir. Unutulmamalıdır ki, bu şekilde enjekte edilen her zaman yerel uygulamadır (burada IDaoLocal). Bu enjeksiyon, web hizmetinin EJB ile aynı JVM'de çalışması nedeniyle mümkündür.
• Web hizmetinin tüm yöntemleri, uzak istemcilere görünür hale getirmek için @WebMethod anotasyonu ile etiketlenmiştir. @WebMethod anotasyonu ile etiketlenmemiş bir yöntem, web hizmetinin dahili bir yöntemi olur ve uzak istemciler tarafından görülemez. Web hizmetindeki her M yöntemi, 7. satırda enjekte edilen EJB'nin karşılık gelen M yöntemini çağırmakla yetinir.

Bu web hizmetinin oluşturulması, NetBeans projesinde yeni bir dal olarak yansıtılır:

[1]'te WsDaoJpa web hizmeti, [2]'te ise uzak istemcilere sunduğu yöntemler görülmektedir.

Geliştirilmekte olan web hizmetinin mimarisini hatırlayalım:

Dağıtacağımız web hizmetinin bileşenleri şunlardır:

• [1]: az önce oluşturduğumuz web modülü
• [2]: Bir önceki adımda oluşturduğumuz ve web hizmetinin bağımlı olduğu EJB modülü

Bunları birlikte dağıtmak için, iki modülü de "kurumsal" olarak adlandırılan bir NetBeans projesinde bir araya getirmemiz gerekir:

[1] projesinde, [2, 3] adlı yeni bir kurumsal proje oluşturulur.

• [4,5]'te projeye bir ad verilir ve oluşturulacağı klasör belirlenir
• [6] adımında, kurumsal uygulamanın dağıtılacağı uygulama sunucusu seçilir
• [7] adımında, bir kurumsal proje üç bileşene sahip olabilir: web uygulaması, EJB modülü, istemci uygulaması. Burada proje herhangi bir bileşen olmadan oluşturulur. Bu bileşenler daha sonra eklenecektir.

• [8]'te, yeni oluşturulan kurumsal uygulama.

• [9]'te, [Java EE Modules]'e sağ tıklayın ve yeni bir modül ekleyin
• [10]'te, yalnızca IDE'te şu anda açık olan NetBeans modülleri gösterilir. Burada, oluşturduğumuz [serveur-webservice-1-ejb-dao-jpa-hibernate] web modülünü ve [serveur-ejb-dao-jpa-hibernate] EJB modülünü seçiyoruz.
• [11]'te, kurumsal projeye eklenen iki modül.

Şimdi bu kurumsal uygulamayı Glassfish sunucusuna dağıtmamız gerekiyor. Devamında, EJB modülü tarafından kullanılan "jdbc/dbrdvmedecins" veri kaynağına erişilebilmesi için SGBD ve MySQL modüllerinin başlatılması gerekir.

• [1]'te Glassfish sunucusu başlatılır
• [serveur-ejb-dao-jpa-hibernate] EJB modülü dağıtılmışsa, bu modül kaldırılır [2]
• [3]'e, kurumsal uygulamayı dağıtırız

• [4]'te uygulama dağıtılmıştır. Uygulamanın hem Web hem de EJB modüllerini içerdiği görülmektedir.

4.10.2. NetBeans Projesi - sürüm 2

Şimdi, EJB modülünün kaynak koduna sahip olmadığımız, sadece .jar arşivine sahip olduğumuz durumda web hizmetini nasıl dağıtacağımızı göstereceğiz.

Web hizmetinin yeni NetBeans projesi şu şekilde olacaktır:

Projenin dikkat çeken unsurları şunlardır:

• [1]: Web hizmeti, [Web Application] türünde bir NetBeans projesi ile uygulanmaktadır.
• [2]: Web hizmeti, daha önce incelenen [WsDaoJpa] sınıfı ile uygulanmaktadır.
• [3]: [dao] katmanının EJB arşivi; bu arşiv, [WsDaoJpa] sınıfının [dao] ve [jpa] katmanlarındaki çeşitli sınıf, arayüz ve varlık tanımlarına erişmesini sağlar.

Ardından, web hizmetinin devreye alınması için gerekli kurumsal projeyi oluşturuyoruz:

• [1]'te, başlangıçta hiçbir modül içermeyen bir kurumsal uygulama olan [ea-rdvmedecins]'i oluşturuyoruz.
• [2]'te, önceki web modülünü [serveur-webservice-ejb-dao-jpa-hibernate]
• [3]'te sonuç.

Bu haliyle, [ea-rdvmedecins] kurumsal uygulaması NetBeans'ten GlassFish sunucusuna dağıtılamaz. Bir hata mesajı alınır. Bu durumda, [ea-rdvmedecins] uygulamasının ear arşivini manuel olarak dağıtmak gerekir:

• [ea-rdvmedecins.ear] arşivi, NetBeans'in [dist] [2] sekmesindeki [Files] klasöründe bulunur.
• Bu [3] arşivinde, kurumsal uygulamanın iki öğesi bulunur:
• [serveur-ejb-dao-jpa-hibernate] adlı EJB arşivi. Bu arşiv, web hizmeti tarafından referans verilen kütüphanelerin bir parçası olduğu için burada yer almaktadır.
• [serveur-webservice- ejb-dao-jpa-hibernate] adlı web hizmeti arşivi.
• [ea-rdvmedecins.ear] arşivi, kurumsal uygulamanın basit bir Build [4]'inden oluşturulmuştur.
• [5]'te, dağıtım işlemi başarısız oluyor.

Kurumsal uygulamanın [ea-rdvmedecins.ear] arşivini dağıtmak için, 4.2. paragrafında EJB [serveur-ejb-dao-jpa-hibernate.jar] arşivinin dağıtımında gösterildiği gibi ilerliyoruz. Yine GlassFish sunucusunun web yönetim istemcisini kullanıyoruz. Daha önce açıklanan adımları tekrarlamayacağız.

Öncelikle, 4.10.1 numaralı paragrafta dağıtılan kurumsal uygulamayı "kaldırmaya" başlayacağız:

• [1]: Glassfish sunucusundaki [Enterprise Applications] dalını seçin
• [2]'te kaldırılacak kurumsal uygulamayı seçin, ardından [3]'te uygulamayı kaldırın
• [4]'te kurumsal uygulama indirilmiştir

• [1]'te, Glassfish sunucusunun [Enterprise Applications] dalını seçin
• [2]'te, yeni bir kurumsal uygulama dağıtın
• [3]'te, [Enterprise Application] türünü seçin
• [4]'te, NetBeans projesinin .ear dosyasını belirtin [ea-rdvmedecins]
• [5]'te, bu arşivi dağıtın

• [6] olarak dağıtın; uygulama dağıtılmıştır
• [7]'e dağıtıldı, [WsDaoJpa] web hizmeti Glassfish sunucusunun [Web Services] dalında görünür. Bunu seçin.
• [8]'te, web hizmeti hakkında çeşitli bilgiler bulunur. Bir müşteri için en ilginç olan bilgi [9]'tedir: web hizmetinin URI'si.
• [10]'te web hizmetini test edebiliriz

• [11] adresinde, web hizmetinin URI'sine ?tester parametresi eklenmiştir. Bu URI bir test sayfası gösterir. Web hizmeti tarafından sunulan tüm yöntemler (@WebMethod) görüntülenir ve test edilebilir. Burada, müşteri listesini isteyen [13] yöntemini test ediyoruz.

• [14] örneğinde, yanıt sayfasının yalnızca bir kısmını gösteriyoruz. Ancak getAllClients yönteminin müşteri listesini başarıyla döndürdüğü görülebilir. Ekran görüntüsü, yanıtın XML biçiminde gönderildiğini göstermektedir.

Bir web hizmeti, XML adlı bir dosya tarafından tamamen tanımlanır; bu dosyaya WSDL dosyası denir:

• Glassfish sunucusunun web yönetim aracında [1] dosyasında, [WsDaoJpa] web hizmetini seçin
• [2]'e, [View WSDL] bağlantısını takip edin

• [3]: WSDL dosyasının URI'si. Bu, bilinmesi gereken önemli bir bilgidir. Bu web hizmetinin istemcilerini yapılandırmak için gereklidir.
• [4], web hizmetinin XML açıklamasıdır. Bu karmaşık içeriği yorumlamayacağız.

4.10.3. Web hizmetinin JUnit testleri

Daha önce bir EJB istemcisiyle gerçekleştirilen testleri, bu sefer son olarak devreye alınan web hizmeti için bir istemci kullanarak "tekrar etmek" amacıyla bir NetBeans projesi oluşturuyoruz. Burada, [ref1]'in 115. sayfasındaki 14.2.1 numaralı paragrafta açıklanan yaklaşıma benzer bir yöntem izliyoruz.

• [1]'te, klasik bir Java projesi
• [2]'te, test sınıfı
• [3]'te, istemci, [dao] katmanının arayüz tanımlarına ve JPA varlıklarına erişmek için EJB arşivini kullanır. Bu arşivin, EJB modülünün klasöründeki [dist] alt klasöründe bulunduğu hatırlatılmalıdır.

Uzak web hizmetine erişmek için proxy sınıfları oluşturulması gerekir:

Yukarıdaki şemada, [2] ve [C=Client] katmanları, [1] ve [S=Serveur] katmanlarıyla iletişim kurmaktadır. [S] katmanıyla iletişim kurmak için, [C] istemcisi, [S] katmanıyla bir ağ bağlantısı kurmak ve belirli bir protokol uyarınca bu katmanla iletişim kurmak zorundadır. Ağ bağlantıları TCP bağlantılarıdır ve aktarım protokolü HTTP'tir. Web hizmetini temsil eden [S] katmanı, Glassfish sunucusu tarafından çalıştırılan bir Java servlet ile uygulanır. Bu servleti biz yazmadık. Oluşturulması, bizim yazdığımız [WsDaoJpa] sınıfındaki @Webservice ve @WebMethod anotasyonları temelinde Glassfish tarafından otomatik olarak gerçekleştirilir. Benzer şekilde, istemcinin [C] katmanının oluşturulmasını da otomatikleştireceğiz. [C] katmanı bazen uzak web hizmetinin proxy katmanı olarak adlandırılır; proxy terimi ise bir yazılım zincirindeki ara elemanı ifade eder. Burada, C proxy'si, yazacağımız istemci ile dağıttığımız web hizmeti arasındaki ara elemandır.

NetBeans 6.5 ile C proxy'si şu şekilde oluşturulabilir (devamında, web hizmetinin GlassFish sunucusunda aktif olması gerekir):

• [1]'te, Java projesine
• [2]'te, [Web services] dalını seçin
• [3]'te, [Web Service Client]'i seçin

• [4]'te, web hizmetinin WSDL dosyasının URI'sini girin. Bu URI, 4.10.2. paragrafında açıklanmıştır.
• [5]'te, varsayılan değer olan [JAX-WS]'i koruyun. Diğer olası değer [JAX-RPC]'tir
• Web hizmeti proxy oluşturma sihirbazını onayladıktan sonra, NetBeans projesine [Web Service References] ve [6] dalları eklenmiştir. Bu dallar, uzak web hizmeti tarafından sunulan yöntemleri gösterir.

• [Files] ve [7] sekmelerinde, [8] adlı Java kaynak kodları eklenmiştir. Bunlar, oluşturulan C proxy'sine karşılık gelir.
• [9]'te sınıflarından birinin kodu yer almaktadır. Burada, sınıfların bir pakete yerleştirildikleri görülmektedir ([10]). Bu sınıfların kodu yine oldukça karmaşık olduğundan, bu konuda yorum yapmayacağız.

Şu anda oluşturmakta olduğumuz Java istemcisi için, oluşturulan C proxy'si aracı görevi görüyor. Uzak web hizmetinin M yöntemine erişmek için Java istemcisi, C proxy'sinin M yöntemini çağırıyor. Böylece Java istemcisi yerel yöntemleri (aynı JVM'de yürütülen) çağırıyor ve istemci için şeffaf bir şekilde bu yerel çağrılar uzak çağrılara dönüştürülüyor.

Geriye, C proxy'sinin M yöntemlerini nasıl çağıracağımızı öğrenmek kalıyor. JUnit test sınıfımıza geri dönelim:

[1]'te, [MainTestsDaoRemote] test sınıfı, [dao] katmanındaki EJB'nin testinde zaten kullanılmış olan sınıftır:

package dao;
...
public class MainTestsDaoRemote {

   // [dao] katmanı test edildi
  private static IDaoRemote dao;

  @BeforeClass
  public static void init() throws NamingException {
  }

  @Test
  public void test1() {
...
  }
}

• [13] satırında, test1 testi aynen korunmuştur.
• [9] satırında, [init] yönteminin içeriği silinmiştir.

Bu aşamada, [test1] test yöntemi artık eskisiyle aynı paketlerde bulunmayan [Client], [Medecin], [Creneau], [Rv] varlıklarını kullanmaktadır ve bu varlıklar artık eskisi gibi aynı paketlerde bulunmamaktadır. Bu varlıklar, oluşturulan C proxy paketinde yer almaktadır. İlgili import talimatları silinmeli ve "Fix Imports" işlemiyle yeniden oluşturulmalıdır.

[MainTestsDaoRemote] test sınıfının koduna geri dönelim:

package dao;
...

public class MainTestsDaoRemote {

   // [dao] katmanı test edildi
  private static IDaoRemote dao;

  @BeforeClass
  public static void init() throws NamingException {
}

1. satırdaki [init] yöntemi, 7. satırdaki [dao] katman referansını başlatmalıdır. Kodumuzda oluşturulan C proxy'sini nasıl kullanacağımızı bilmemiz gerekir. NetBeans bu süreçte bize yardımcı olur.

• [1] içinde web hizmetinin [getAllClients] yöntemini seçin ve fareyle bu yöntemi sürükleyip test sınıfındaki [init] yönteminin içine bırakın.

Sonuç olarak [2] elde edilir. Bu kod şablonu, oluşturulan C proxy'sinin nasıl kullanılacağını gösterir:

    try { // Web Hizmeti Çağrısı İşlemi
      rdvmedecins.ws.WsDaoJpaService service = new rdvmedecins.ws.WsDaoJpaService();
      rdvmedecins.ws.WsDaoJpa port = service.getWsDaoJpaPort();
       // TODO sonucu burada işlenir
      java.util.List<rdvmedecins.ws.Client> result = port.getAllClients();
      System.out.println("Result = "+result);
    } catch (Exception ex) {
       // TODO özel istisnaları burada işleyin
}

• [5] satırı, [getAllClients] yönteminin 3. satırda tanımlanan [WsDaoJpa] türündeki nesnenin bir yöntemi olduğunu gösterir. [WsDaoJpa] türü, uzak web hizmeti tarafından sunulan yöntemlerin aynısını içeren bir arayüzdür.
• [3] satırında, [WsDaoJpa port] nesnesi, 2. satırda tanımlanan [WsDaoJpaService] türündeki başka bir nesneden elde edilir. [WsDaoJpaService] türü, yerel olarak oluşturulan C proxy'sini temsil eder.
• Uzak web hizmetine erişim başarısız olabilir, bu nedenle tüm kod bir try / catch bloğu içine alınmıştır.
• C proxy nesneleri, [rdvmedecins.ws] paketinde bulunur.

Bu kodu anladıktan sonra, uzak web hizmetinin yerel referansının şu kodla elde edilebileceği görülür:

WsDaoJpa dao=new WsDaoJpaService().getWsDaoJpaPort();

Böylece JUnit test sınıfının kodu şu şekilde olur:

package dao;

import rdvmedecins.ws.Client;
import rdvmedecins.ws.Creneau;
import rdvmedecins.ws.Medecin;
import rdvmedecins.ws.Rv;
import rdvmedecins.ws.WsDaoJpa;
import rdvmedecins.ws.WsDaoJpaService;
...

public class MainTestsDaoRemote {

   // [dao] katmanı test edildi
  private static WsDaoJpa dao;

  @BeforeClass
  public static void init(){
    dao=new WsDaoJpaService().getWsDaoJpaPort();
  }

  @Test
  public void test1() {
...
  }

   // yardımcı yöntem - bir koleksiyondaki öğeleri görüntüler
  private static void display(String message, List elements) {
 ...
  }
}

Artık testlere hazırız:

[1]'te, JUnit testi yürütülür. [2]'te test başarılı olur. NetBeans konsolundaki çıktılara bakıldığında, aşağıdaki gibi satırlar görülür:

Liste des clients :
rdvmedecins.ws.Client@1982fc1
rdvmedecins.ws.Client@676437
rdvmedecins.ws.Client@1e4853f
rdvmedecins.ws.Client@1e808ca

Sunucu tarafında, [Client] varlığı, [Client] türündeki bir nesnenin çeşitli alanlarını görüntüleyen toString yöntemine sahiptir. C proxy'sinin otomatik olarak oluşturulması sırasında, varlıklar C proxy'sinde oluşturulur, ancak yalnızca özel alanlar ve bunlara ait get / set yöntemleri eklenir. Bu nedenle, toString yöntemi, C proxy'sindeki [Client] varlığında oluşturulmamıştır. Bu durum, önceki ekrandaki görüntüyü açıklamaktadır. Bu durum, JUnit testinin sonucunu etkilemez: test başarılı olmuştur. Artık web hizmetinin çalışır durumda olduğu kabul edilecektir.