POJO ve JavaBean Nedir

Plain Old Java Object

POJO’dan bahsederken, bu kavramın herhangi bir framework ile alakası olmadığını belirteyim. POJO isimlendirmesi yaparken de sabit bir naming convention kullanım zorunluluğu da bulunmamakta. Basit bir POJO şu şekilde oluyor:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public class SomePojo {
    private String fname;
    private String lname;

    public SomePojo(String fname, String lname) {
        this.fname = fname;
        this.lname = lname;
    }

    private String getFname() {
        return fname;
    }

    public void setFname(String fname) {
        this.fname = fname;
    }

    public String getLname() {
        return lname;
    }

    public void setLname(String lname) {
        this.lname = lname;
    }
}

Oluşturmuş olduğumuz bu java sınıfı, framework’lerden bağımsız istenildiği gibi kullanılabilir. Başka herhangi bir nesne ile bağlantısı olmayan, bünyesinde instance variable, constructor, getter, setter ve toString gibi metodları barındırabilen en temel objedir. Çok basit tanımlarsak eğer Java nesnelerine verilen isim olarak belirtebiliriz. Bazı kaynaklar bunun herhangi bir framework’e veya başka bir sınıfa bağımlılığı olmayan bir sınıf olarak tanımlıyor. Çok basit bir class oluşturup içerisine getter,setter ve constructor tanımladığımızı düşünelim. Artık bu sınıf bizim için POJO’yu ifade ediyor diyebiliriz.

Başka bir örnek verecek olursak da örneğin bir API’den data çekiyorsunuz ve dönen datayı bir java objesi olarak tutmak istediniz. Yine en temel şekilde POJO’muzu oluşturup gelen dataları setter metodları veya constructor ile class’ımızın ilgili değişkenlerine atayarak bir obje oluşturdunuz. POJO hayırlı olsun diyip işlere devam edebilirsiniz. POJO kavramını bu anlattıklarım gibi oldukça basit ve sade olarak en temel basit bir java objesi oluşturabileceğiniz bir sınıf olarak düşünebilirsiniz.

Java Bean

Araştırmalarıma dayanarak bir java sınıfının Bean olarak tanımlanabilmesi için şu özelliklere sahip olması gerekiyor:

• Public Constructor’a sahip olması
• Serializable olması (implements Serializable)
• Instance Variable erişimleri Getter/Setter metodları ile tanımlanmalı

Bu şartlardan yola çıkarak şöyle bir çıkarımda da bulunmamız gerekiyor. Her Java Bean bir POJO’dur. Ancak her POJO bir Java Bean değildir. Özellikle iş arayanlar için POJO ve Bean kavramlarının ne olduğuna dair sorular sık sık karşınıza gelecektir.

Spring Bean

Öncelikle Spring IoC hakkında bilginiz yoksa bu konudan daha iyi yararlanmanız adına öncelikle o konuyu okumanızı tavsiye ederim. Bean kavramını Spring Framework yapısında merak ediyorsanız onu da şöyle ifade etmeye çalışayım ki bu konu kendi başına yeni bir yazı olabilecek niteliktedir. Bean kavramı Spring için temel konsepttir desek hatalı bir söylem ifade etmiş olmayız. Spring’i anlayabilmenin yolu Bean kavramını anlamaktan geçmekte.

Spring IoC Container tarafından örneklenen ve yönetilen, uygulamamızın temel yapıtaşlarını oluşturan şeylere Bean diyoruz. Bean kavramını anlamak için IoC kavramını da öğrenmeniz gerekmektedir.

Normal bir class’I başka bir class içerisinde kullanmak istersek:

1

AnotherClass myClass = new AnotherClass();

gibi o java sınıfından bir obje oluşturmamız gerekiyordu. Ancak Spring uygulamamız ilk defa ayağa kalkarken Spring’e özel annotation’lar ile işaretlediğimiz class’lardan bir obje oluşturur ve bu objeleri IoC Container içerisine koyar. Biz de yukarıda olduğu gibi yeni objeler oluşturmak yerine aşağıda göreceğiniz gibi bu objeleri IoC Container içerisinden alıp kullanmak için bir takım işlemler yaparız. Örnek verecek olursak Spring projelerimizde bir Controller sınıfı içerisine bir Config, Service ya da Repository objemizi aktarmak istediğimizde bunu Constructor Injection ile şu şekilde yapabiliriz:

1
2
3
4
5
6
7
8
9

@Controller
public class SomeController {
    private final SomeService service;

    @Autowired
    public SomeController(SomeService service) {
        this.service = service;
    }
}

Burada kullandığımız @Autowired ifadesini aynı zamanda constructor olmadan şu şekilde de kullanabilirdik ki buna da Field Injection adı verilmekte:

1
2
3
4

public class SomeController {
    @Autowired
    private SomeService service;
}

Ancak bu şekilde ki kullanımlarda debug şansınız kaybolur çünkü variable assignment yapmadığımız için debug atacak bir satır olmuyor. Bu nedenle constructor içerisinde initialize edilecek şekilde kullanmanızı öneririm.

Servis sınıfımız da şu şekilde olsun:

1
2
3
4

@Service
public class SomeService {
    //
}

Konumuza dönecek olursak @Autowired ifadesi ile controller sınıfımıza inject ettiğimiz servis sınıfımız kendisini @Service notasyonu ile tanımlamamızdan dolayı, uygulamamız ilk ayağa kalkarken bu service sunıfından bir bean oluşturuyor ve bunu Spring IoC içerisine atıyor. Bu service objemize bağımlı olan controller sınıfımız da IoC içerisinde tanımlanan bu objeyi kendi içerisine inject ediyor. Yani sıfırdan yeni bir obje oluşturmak yerine varolan objeyi kullanıyor. Çünkü Spring bizim için uygulamamızı kaldırırken sınıfımızdan yeni bir instance oluşturarak IoC Container’a koydu. Biz de lazım oldukça oradan alarak bu instance’ı kullanacağız.

Oluşturulmuş olan Bean, default olarak Singleton bean scope yapısına sahip olduğundan yalnızca 1 defa örneklenmiş oldu. Eğer aynı service/repository/configuration… yapısından farklı Bean’ler oluşturmak isteseydik o zaman Bean’in yaşam döngüsünü farklı olarak Prototype belirleyebilirdik. Buradan da bir Bean hangi scope’lara sahip olabilir ve bu scope değerleri ne işe yarar, anlamları nedir veya ne değildir onları okuyabilirsiniz.