Log4J Nedir?

Merhaba arkadaşlar, bu yazımda size Log4J adlı bir loglama kütüphaneden bahsedeceğim.

Öncelikle loglama nedir?

Loglama bir sistemin hareketlerini kaydeden bir yapıdır. Özellikle sistem yöneticileri ve hata gideren kullanıcılar ve hatta geliştiriciler için bir vazgeçilmezdir. Log4J ‘den önce de loglama yapılıyordu aslında, log4J standart loglama kütüphanesini kullanarak işleri bizim için biraz daah kontrollü ve kolay hale getiriyor.

Bu kütüphaneyi kullanabilmek için ise log4j jar dosyası ve log4j properties dosyası yeterlidir.

Log4j ‘de loglama seviye bazlıdır. Bu seviyeler properties dosyasından ayarlanabilmektedir.

log 1

Görüldüğü üzere seviye merkeze doğru gittikçe loglama kapması azalır. Örnek bir log4j.properties dosyası:

# logger options: ALL -> DEBUG -> INFO -> WARN -> ERROR -> FATAL -> OFF

# Root logger option
log4j.rootLogger=DEBUG, file, stdout

# Direct log messages to a daily log file
log4j.appender.file=org.apache.log4j.DailyRollingFileAppender
log4j.appender.file.File=log/loging.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L – %m%n

# Direct log messages to stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L – %m%n

Örnek kullanım için sınıf içerisine ilk olarak log4j için bir nesne oluşturmamız gerekli,

private static final Logger logger = Logger.getLogger(SınıfAdi.class);

Gördüğünüz gibi sınıf adı da kullanılarak bir nesne oluşturuluyor. Bunun nedeni hangi loğun hangi sınıftan yazdırıldığının da kaydını tutuyor olmamız.

Bir log mesajı yazdırmak için örnek kodlar:

logger.fatal("fatal log message");
logger.error("error log message");
logger.warn("warn log message");
logger.info("info log message");
logger.debug("debug log message");
logger.trace("trace log message");

 

Her işlem ya da logic kontrol sırasında logger kullanmak ileri yönlü hata kontrolü sağlayacaktır. Çünkü katmanlı projelerde bir hatanın bulunması zaman zaman gerçekten zor olabiliyor. Küçük projelerde pek gerek kalmasa da bunu bir alışkanlık hale getirmek oldukça faydalı olacaktır.

EOC(End Of Code)

Tasarım Desenleri Nedir, Neden Kullanılır?

Merhaba arkadaşlar, bu yazımda size nesneye dayalı programlamayla ilgili olarak önemli bir konu olan tasarım desenlerinden bahsedeceğim. Tasarım desenleri programlama dilinden bağımsızdır. Yazılım geliştirme sürecinde sürekli karşılaşılan problemlere yapılan denemeler sonucunda en uygun çözümler geliştirilmiş ve bunlara tasarım desenleri adı verilmiştir. Bazı özelliklerinden bahsedecek olursak:

  • Her şeyi yeni baştan oluşturmayı önlerler
  • Tekrar tekrar kullanılabilirler
  • Birlikte kullanılarak çok daha büyük problemlerin çözümünde kullanılabilirler
  • Sürekli gelişime açıktırlar

Tasarım desenleri 3 ana gruba ayrılır. Bunlar oluşturucu, yapısal ve davranışsal tasarım desenleridir. Oluşturucu tasarım desenleri, sınıfların en uygun ve verimli oluşturulma düzenleriyle ilgili tasarım desenleridir. Yapısal tasarım desenleri, sınıflar arasındaki ilişkilerin yönetilmesine yönelik tasarım desenleridir. Davranışsal tasarım desenleri ise, sınıfların birbiriyle nasıl haberleşmesi gerektiğine yönelik tasarım desenleridir.

Birkaç tasarım desenini kısaca açıklamaya çalışalım.

Singleton(Tekillik)

Bu tasarım deseni, bir sınıftan sadece bir tane nesne oluşturulması için kısıtlama sağlamaktadır. Aslında farkında olmadan kullandığımız bu tasarım desenine örnek vermek gerekirse, JSF ‘deki FacesContext.getCurrentInstance() söylenebilir.

Basitçe söylemek gerekirse, bu tasarım deseninde bir sınıfımızın olduğunu ve içerisinde de private static olarak kendisinden bir nesne tanımlandığını düşünelim. Bir static metot yardımıyla bu nesneyi döndüğümüzü düşünelim. Son olarak da boş bir protected kurucu tanımladığımızı düşünürsek, bu sınıftan soyut bir sınıf olmamasına rağmen yeni bir nesne oluşturamayız. Tek yol olarak tanımladığımız metotdan dönen static nesnedir.

Bunu örnek bir sınıfla pekiştirelim.

public class SingletonSinif {
    private static SingletonSinif instance = null;
    protected SingletonSinif () {
    }
    public static SingletonSinif getInstance() {
        if(instance == null) {
            instance = new SingletonSinif ();
        }
        return instance;
    }
}

Görüldüğü gibi bu sınıftan sadece bir nesne oluşturulabilmektedir.

Peki, neden bir sınıftan sadece bir nesne oluşturmamız gerekir, ne zaman kullanmamız gerekir. Açıkça söylemek gerekirse bu konuda verilecek örnekler kullanım alanının çok küçük bir parçası olacaktır. Şimdi şöyle düşünelim, projenizde kullanacağınız global değişkenler var ve bunlar sürekli erişime ve değişime açık olmalılar. Aynı zamanda da her yerden erişmeniz de gerekiyor. Ne de olsa global dedik. Şimdi bunun için en uygun çözüm singleton bir sınıf tanımlamaktır.

Umarım anlatmak istediğimi anlamışsınızdır.

Builder(Oluşturucu)

Bu tasarım deseni, bir sınıftan farklı özelliklere sahip nesneler üretilmesi için kolaylaştırılmış bir yol sunmaktadır. Bir sınıf tanımladığımızı düşünelim ve bu sınıfın farklı alt alanları için farklı tasarlanmış kurucu fonksiyonları olduğunu düşünelim. Şimdi her bir farklı durum için yeni bir kurucu tanımlamamız gerekiyor. Bu hem yorucu hem de kod okunabilirliğini azaltıyor. İşte bu durumda yardımımıza bu tasarım deseni koşmakta. Sadece tek bir kurucu kullanıyormuş gibi işimizi kolaylaştırıyor ve okunabilirliği arttırıyor.

Pekala, şimdi bu tasarım desenini yapısından bahsedelim. Bir sınıfımız var ve bu sınıfımızın alt alanları bulunmakta. İlk olarak içerisinde static bir iç sınıf tanımladığımızı düşünelim. İçerisinde de bizim farklı durumlarda sürekli değişen alt alanlarımız olsun. Bu alt alanların set metotlarını tanımlıyoruz. Daha sonra ana sınıfımız için bir kurucu tanımlayıp parametre olarak bu sınıftan bir nesne alıyoruz. Şimdi son olarak da iç sınıfımızda bir metot tanımlayıp döndürdüğü nesne olarak da yeni bir ana sınıfımızdan nesne gönderiyoruz. Parametre olarak da kendisini gönderiyor.

Bu açıklamanın havada kaldığını ve anlaşılmadığını biliyorum ancak örnek kodu inceledikten sonra anlayacağınıza eminim.

public static class Builder {
        private final double price;
        private String color, brand;
        private int year;
        private boolean isSecondHand;

        public Builder(double price) {
            this.price = price;
        }

        public Builder setColor(String color) {
            this.color = color;
            return this;
        }

        public Builder setBrand(String brand) {
            this.brand = brand;
            return this;
        }

        public Builder setYear(int year) {
            this.year = year;
            return this;
        }

        public Builder secondHand(boolean isSecondHand) {
            this.isSecondHand = isSecondHand;
            return this;
        }

        public Car build() {
            return new Car(this);
        }
    }

    private Car(Builder builder) {
        price = builder.price;
        brand = builder.brand;
        color = builder.color;
        isSecondHand = builder.isSecondHand;
        year = builder.year;
    }
}

Pekala, sanırım bu örnekte bir farklılık var, o da builder yani iç sınıfımızın kurucusunun parametre alması. Bunu şöyle açıklayabiliriz, değişmeyen alt alanlarınız varsa bu şekilde kurucuya parametre alarak gereksiz kod kalabalığından kurtulmamızı sağlıyor. Örnek kullanımına bakacak olursak:

Car myCar = new Car.Builder(1250.12)
        .setBrand(“Opel”)
        .secondHand(true)
        .setColor(“Black”)
        .setYear(1995)
        .build();

Bu sadece basit bir örnek, bunu geliştirmek ihtiyacınıza ve hayal gücünüze kalmış.

EOC(End Of Code)

S.O.L.I.D. Principles(İlkeleri) Nedir, Neden Kullanılır?

Merhaba arkadaşlar, bu yazımda size SOLID kısaltmasından bahsedeceğim. Tabi ki sadece kısaltmanın anlamından değil biraz detayından da bahsetmeye çalışacağım. SOLID aslında OOP(Object Oriented Programming yani Türkçesiyle nesneye dayalı programlama) yaparken uymamız gereken ilkeler denilebilir. Kullanımı zorunlu değildir ancak, kullanılmadığında çok başınızın ağrıyacağına garanti veriyorum kendi tecrübelerimden.

OOP denildiğinde akla gelen şey, okullarda bize gösterilen kalıtım, arayüzler vs. daha fazlası değil. Bu OOP kullanım tarzıyla geliştirmiş olduğum projelerde çalışmalarım devam ettikçe proje ömrünün ve yeniden kullanım imkanının çok az olduğunu farkettim. Yazılarımda Tasarım Desenleri bu sorunun çözüm kaynaklarından biri. Ancak etkili bir çözüm için SOLID ilkelerine uymak gerekiyor.

SOLID ilkeleri için basitçe söylemek gerekirse OOP ‘de bağımlılık yönetimi biçimidir. Bu ilkeler olmadan oluşturulan projeler esneyemez, kırılgan ve sabit özelliklerde oluyor. Yeni bir özellik ya da güncelleme yapmak istediğinizde projeyi baştan değiştirmeniz bile gerekebiliyor. Bunun nedeni kötü proje mimarisidir.

SOLID ilkelerinde anahtar kelime Loose Coupling yani gevşek bağımlılıktır. Sınıf ve arayüz ilişkilerinde bağımlılık ne kadar az olursa proje o kadar esnek olacaktır. Artık şu SOLID ‘i açıklayalım.

S – Single Responsibility Principle (SRP)

Bir sınıfın sadece bir sorumluluğu olmalıdır. Bir sınıf birden fazla işle ya da katmanla ilişkilendirilirse yönetimi ve geliştirimi zorlaşır.

O – Open/Closed Principle (OCP)

Bir sınıf gelişime açık, ancak değişime(mevcut kodların) kapalı olmalıdır. Bir sınıfa yeni bir özellik ekleme halinde sınıfın mevcut kodlarının değişmesi gerekiyorsa bu o sınıfın Loose Coupling kuralında uymadığı anlamına ve yeterli esneklik sağlamadığı anlamına gelir.

L – Liskov ‘s Substitution Principle (LSP)

Sınıfların kendi alt sınıflarıyla değiştirilebilir olması gerekmektedir. Basit bir örnek olarak çok biçimlilik konusu örnek verilebilir. Ancak bu durumun tam tersinin de işleyebiliyor olması gerekmektedir.

I – Interface Segregation Principle (ISP)

Arayüzlerin ayrımı anlamına gelen bu ilke, bir arayüzü implemente alan sınıfların gereksiz (kullanılmayan) metotları bulundurmaya zorlanmasının önlenmesidir. Mümkün olduğunda ortak özellikler arayüz halinde tasarlanmalı ve gerekirse farklı arayüzler birbirinden extend almalıdır.

D – Dependency Inversion Principle (DIP)

Yüksek seviyeli sınıflar, düşük seviyeli sınıflara bağımlı olmamalıdır her ikisi de soyut kavramlara bağlı olmalıdır. Çünkü somut sınıflarda değişikliklerin meydana gelme durumu daha fazladır.

Bu tanım sanırım oldukça genel ancak biraz daha açmak gerekirse, bir sınıf başka bir sınıf içerisinde bir örneği bulunduğu durumları göz önüne alalım. Bu sınıfta yapılmak istenecek ufak bir değişiklik O ilkesini çiğneyecektir. Bu yüzden farklı bir yaklaşım olarak bu sınıfları bir soyut sınıf veya arayüz yardımıyla birbirine bağlamak daha doğru olacaktır.

Bu ilkeler uyulması halinde geliştirdiğiniz her proje sizin için bir ilerleme olacaktır. Nasıl bir ilerleme derseniz, mesela her seferinde aynı sınıfları yeniden tanımlamak zorunda kalmazsınız. Daha önceki projelerinizdeki kodlarınızı Maven ve Tasarım Desenleri sayesinde yeni projeniz için adapte ederek bir adım daha atarsınız. Bu şekilde geliştirme yapmak size daha büyük projeleri daha kısa zamanlarda geliştirme imkânı verecektir.

EOC(End Of Code)

 

UML Nedir?

Merhaba arkadaşlar, size bu yazımda UML(Unified Modeling Language)’ den bahsedeceğim. UML bir programlama dili değildir, aksine bir modelleme dilidir. Bir projenin her türlü bileşeninin ve bu bileşenlerin aralarındaki ilişkilerin görsel olarak ifade edilebilmesini sağlayan bir standarttır. Büyük çaplı projelerde karmaşık yapıları hem geliştirme takımına kolayca aktarmak hem de projenin mimarisini daha proje geliştirilmeye başlanmadan önce belirlemek için oluşturulmuştur.

UML, programlama dillerinden bağımsızdır, temelde bir notasyon dilidir. Ancak görsel modelleme yaparak, yazılımın daha görülebilir hale gelmesini sağlarız. OOP yaklaşımını kullandığı için temel OOP ilişkilerini bile tanımlamamız mümkündür. Çalıştırılabilir bir dil olmamasına rağmen, Executable UML adı altında birkaç çalışma vardır. UML ile geliştirdiğiniz modellerden size istediğiniz dilde, iskelet bir kod bütünü oluşturma imkanı verir.

UML, bir yazılımın geliştirme sürecinde yer alan farklı yönelimleri modelleyecek farklı diyagramlara sahiptir.

uml 1

UML sadece bir projenin modellenmesi için kullanılmaz. Aslına bakarsak geliştirilmiş UML araçları, UML ‘den çok kullanılmaktadır. UML araçlarıyla modelleme dışında, reverse-engineering de yapmanıza olanak tanır. Yeni bir proje devraldınız ya da bir geliştirme ekibine katıldınız diyelim. Bu durumda proje için “büyük resim” e hakim olmanız gerekmekte, tabi bunun için debug yapabilir ve ayrıntılı şekilde öğrenebilirsiniz. Ancak reverse-engineering ile oluşturulmuş sequence diyagramları kodun genel akışını anlamanızı kolaylaştırır. Yani zamandan tasarruf ve tam hâkimiyet sağlar. Ayrıca sınıf ilişkilerini anlamak için dosya-dosya gezmek de oldukça yorucu oluyor. Ancak bu sizi tam anlamıyla bir UML kullanıcısı yapmaz, siz sadece UML okuyorsunuz. Tabi bunun kötü bir yanı yok.

UML kullanmak, UML diyagramları da yazabilmektir sanırım. Peki UML kullanmak bize gerçekten ne kolaylık sağlar? Yazılım modellemeyi zihinde yapmak en pratiği ancak, bunun da bir sınırı var; aklınıza gelen bir özellik ya da önemli bir hata kurtarma durumu, sınıf sayılarının ve ilişkilerinin fazla olması, bu sınıfların genel kod işleyişi gibi birçok durum var. Bunları takım arkadaşlarınıza anlatmak da kat kat daha zordur. Çünkü somut bir kavram yoktur hâlihazırda, hepsi sizin düşüncelerinizde anlamlıdır. UML kullanarak farklı düşünceler bir araya gelme imkânı bulur, daha iyi çözümleri beraberinde getirir. Ancak UML diyagramlarının hepsini kullanayım de mükemmel bir yazılım geliştireyim sevdasına da düşmemek gerek. UML daha iyi bir yazılım geliştirmenize dolaylı yollardan yardımcı olur ancak asıl işlevi bu değildir. Bu yüzden esas nokta her zaman sizsiniz.

UML diyagramları iki ana başlığa ayrılmıştır. Structure(Yapısal) ve Behaviour(Davranışsal) diyagramlar.

İlk olarak sıklıkla kullanılan ve oldukça faydalı bir diyagram olan Use Case ‘i ele alalım. UC diyagramları projeye ilk bakıldığında görünen davranışları ve fonksiyonlarını, projenin bu davranış ve fonksiyonları üzerinden etkileşimde olduğu insan ya da insan olmayan faktörlerle birlikte kavramsal olarak ifade edilmesidir. Yani projenin ana işleyişi ve özellikleri bu diyagramlardan anlaşılır. Ancak bu diyagramlar tek başına yeterli değildir.

uml 2

Şimdi de diğer bir popüler diyagram olan Activity diyagramlarını ele alalım. Aktivite diyagramı UC diyagramının aktör-sistem etkileşiminin daha iyi betimlenmek için kullanılır. Karmaşık akışlara sahip UC diyagramları için olmazsa olmazdır. Özellikle görseli geliştiricilere hitap etmektedir.

uml 3

Temel olarak UC ve Activity diyagramları, projenin analiz aşamasında oluşturulan ve sistemin davranışsal özelliklerini içeren diyagramlardır.

EOC(End Of Code)  

AOP(Aspect Oriented Programming) Nedir?

Merhaba arkadaşlar, bu yazımda size AOP ‘dan yani Türkçesiyle “Görünüşe Göre Programlama”dan bahsedeceğim. İsim sizi yanıltmasın farklı bir kullanım anlamı var. AOP denildiğinde akla gelen ilk şey sanırım OOP ‘dir. Ancak bu iki programlama yöntemi birbiri için rakip olarak düşünülmesin. AOP, OOP kullanılırken bazı sorunların kolay bir şekilde çözülmesi için geliştirilmiştir. Tabi ki bu sorunların çözüm OOP ‘de var ancak çözüm için birkaç takla atmak gerekiyor.

AOP ‘un yapmak üzere geliştirildiği şey, birbiriyle kesişen ilgileri (Cross-Cutting Concerns) v e bu ilgilerin oluşturduğu karmaşıklığı çözmektir. Yazılım geliştirirken sanırım en zor konulardan biri de bu ilgileri basitleştirmektir. Neden basitleştirmemiz gerekiyor diye soracak olursanız da cevap, gelişime açık ve yeniden kullanılabilir projeler tasarlayabilmek derdim.

AOP, kesişen ya da diğer bir deyişle çakışan ilgileri modüler hale getirebilmek için sınıf ve metotları barındırır. İlgiler modüller halinde tek bir yerde ayrıştırılır ki bu yaklaşım ilgilerin yönetimini kolaylaştırır. Interceptor, AOP ‘un kesişen ilgileri ayırmakta kullandığı kütüphanelerdir ve kelime anlamıyla araya girme, ayırma anlamlarına gelmektedir. Bunlardan bazıları; Ninject, Unity ve Castle ‘dir. Bunları araştırarak detaylı bilgi edinebilirsiniz.

 

EOC(End Of Code)

Restful Web Service Nedir?

Merhaba arkadaşlar, bu yazımda size resful web servislerden yani kısaca rest servislerden bahsedeceğim. Rest servisler tüm bilgilerin kendilerine has birer adrese yani URI(Uniform Resource Idetifier)’e sahip olmasını öngören mimari yaklaşımdır. Tanım oldukça anlamsız geliyor değil mi? Biraz daha açalım öyleyse, rest servisler birer url üzerinden çalışırlar ve bu urller benzersizdir aynı ID gibi. İstemci ve sunucu arasındaki iletişim stateless bir protokol üzerinden (genellikle HTTP) sağlanır.

Restful servislerin Java dünyasındaki standartlarını oluşturan JAX-RS spesifikasyonudur. İlk servislerimi jax-rs standart API ‘i ile yazmıştım. Ancak Spring kullanan arkadaşlara bir tavsiyem Apache CXF kullanmaları yönünde. Farklı servislerden bahsedecek olursak;

  • Jersey: GlassFish grubu tarafından geliştirilmektedir.
  • Apache CXF: Hem SOAP hem de rest servis geliştirmek isteyenler için ideal bir çözüm olacaktır, Spring için CDI uyumluluğu olması yönünden oldukça rahat kullanılabilir.
  • RestEASY: Redhat grubu tarafından geliştirilmektedir. Seam kullanımı için idealdir.
  • Restlet: Jersey ‘den farklı yanı olarak nesneleri serileştirmek için Xstream ve Jackson kullanıyor.

Rest servisler son zamanlarda web ve mobil uygulama geliştirirken oldukça popüler hale geldi. Front-end katmanında Javascript kütüphaneleriyle birlikte kullanıldığında hız bakımından sizi inanılmaz derecede rahatlatıyor. Bir istek ya da veri tabanına veri işlemek için sadece http isteklerinin kullanılması, sayfaların tekrar tekrar gereksiz olarak yeniden yüklenmesini engelliyor. Bu sayede sistem oldukça hızlı bir şekilde çalışıyor.

Restful servisler genel olarak sunucuyla haberleşmek için JSON kullanıyor. Peki bu bize ne sağlıyor? Bu bize, servis katmanının platformdan bağımsız olmasını sağlıyor. Yani bir yandan html kullanırken bir yandan PHP kullanabilir ya da bir adım öteye giderek bir yandan da IOS ve Android uygulamalarda kullanılabiliyor.

Rest servisleri 4 temel http isteğini kullanmaktadır.

  • GET: Genellikle veri ya da veri listelerini getirmek için kullanılır.
  • POST: Veri tabanına yeni bir kayıt eklemek için kullanılır.
  • PUT: Veri tabanındaki verileri güncellemek için kullanılır.
  • DELETE: Veri tabanındaki verileri silmek için kullanılır.

EOC(End Of Code)

 

 

Spring Nedir, Neden Kullanılır?

Merhaba arkadaşlar, bu yazımda size Spring ‘den bahsetmeye çalışacağım. Bu sadece bir yazıda anlatılacak kadar küçük değil, bu yüzden ne olduğundan ve kullanmamız bize nasıl faydalar sağlar gibi şeylerden bahsedeceğim. Sonraki yazılarda daha derinlemesine giriş yapmayı düşünüyorum.

Spring kütüphanesi, J2EE(Java 2 Enterprise Edition) ile web uygulamalarını geliştirirken bize kolaylık sağlamaktadır. Spring rutin işlemleri bizim için arka kısımda hallederek bize hız, performans ve kullanım kolaylığı sağlar. Bu da bize hız, kod sadeliği ve güçlü bir alt yapı sağlıyor. Kurumsal projelerde oldukça popülerdir. Spring 2003 yılında geliştirilmeye başlanmıştır. Spring ‘den önce geliştirilen uygulamalarda katmanlar birbirinden ayrı parçalar halinde bulunmaktaydı. Geliştirimi ve yönetimi oldukça yorucu oluyordu. Spring sayesinde bu katmanları bir uygulama çatısı altında toplamak mümkün hale geldi. Modül bazlı oluşu her alt kütüphanesini eklememize de gerek bırakmıyor. Gelelim faydalarına:

  • Spring, biz geliştiriciler için POJO kullanarak kurumsal bir yapı kurmamızı ve yönetmemizi sağlar,
  • Spring, daha önce de söylediğim gibi modüler olarak geliştirilmiştir, sadece ihtiyacınız olan modülleri ekleyerek gereksiz modül eklememiz için bizi zorlamaz,
  • Spring, ORM yapısıyla bize JEE, JDK ve Kuvars sayaçlarını içerisinde bulundurarak diğer çatı ve kütüphanelerle de çalışma imkanı sunar,
  • Spring kullanılmış projelerde test sınıfları yazmak ve kullanmak kolaydır,
  • Spring kullanmak için büyük bir projeye ihtiyacınız yoktur, her büyüklükteki projeye entegre edilebilir.

Dependency Injection(DI)

Dependency Injection popüler yazılım geliştirme yöntemlerinden biri ve aynı zamanda da Spring ‘in iki önemli yapısından biridir. SOLID ilkelerinden de bilindiği gibi bu yöntem, geliştirici açısından bağımsız sınıflar oluşturmak için kullanılmaktadır. Spring de bu yöntemle birbirinden bağımsız POJO sınıfları oluşturmamızı sağlamaktadır.

Aspect Oriented Programming(AOP)

Spring ‘in diğer önemli yapısıdır, uygulama çalışma zamanında kod yönetimi sağlamaktadır. Örneğin veri tabanına bir kayıt yapılacağı zaman bunun entitymanager ile begin ve commit işlemleri yapılacak notasyonlarla yönetimi sağlanabilmektedir.

Şimdi de Spring ‘in modüllerinden kısaca bahsedelim.

Spring Core: Bu modül, Spring ‘in temelini oluşturur, Loose Coupling gibi yapıları barındırır.

Spring AOP: AOP, Spring tarafından direkt olarak kullanılmasa da deklaratif transaksiyon veya güvenlik uygulamalarında dolaylı olarak kullanılmaktadır.

Spring MVC: Spring MVC, Spring ile Model-View-Controller yapısını oluşturmamızı sağlayan modüldür.

Spring Context: ApplicationContext ve WebApplicationContext gibi yapılar, bu modülde implemente edilmiştir. XML dosyalarında bulunan Spring bean tanımlamaları yapmak ve bu beanları okumak için kullanılmaktadır.

Spring DAO(Data Access Object): Bu modül JDBC gibi teknolojilerin kullanımını basitleştiren sınıfları içermektedir.

Spring ORM(Object Relational Mapping): Bu modül Hibernate,JDO ve TopLink gibi frameworklerle Spring ‘in entegre olmasını sağlamaktadır.

Spring ‘in modülleri bunlarla sınırlı değil ancak şimdilik örnek için yeterli, daha fazla modül için kendi sitesini ziyaret edebilirsiniz.

EOC(End Of Code)

ORM(Object Relational Mapping)&JPA(Java Persistence API) Nedir?

Merhaba arkadaşlar, bu yazımda size kısaca ORM ve JPA ‘dan bahsedeceğim.

ORM

ORM, programlama dillerinden ve veri tabanlarından bağımsız olarak çalışan bir teknolojidir ve işlevi bizim kod bloklarımızla tablolarımız arasında bir köprü oluşturmaktır. Sanırım bu en basit tanım, ancak ne kadar basit bir tanım olsa da sağladığı kolaylıklar oldukça fazladır.

OOP ile katmanlara ayırdığımız projelerimiz ile ilişkisel veri tabanımız arasında veri alışverişini kolaylaştırır. ORM veri tabanımızdaki tablolarımızı tasarladığımız sınıflar ile yönetmemizi sağlar. ORM işlemlerin daha kısalması ve basitleşmesini sağlar.

Hiç SQL yazmadan veri tabanı kullanmanıza olanak verir. Tabi ki karmaşık sorgular yapmak istediğinizde size engel de olmuyor. ORM kullandığınızda veri tabanından bağımsız uygulamalar geliştirebilirsiniz. Sadece ayar dosyalarını değiştirmeniz yeterlidir.

JPA

JPA, ORM ‘i kullanarak oluşturulmuş kütüphanelerin Java ‘daki standardı denilebilir. JPA bir soyut sınıf gibi düşünülürse, ORM örnekleri (Hibernate, TopLink, EclipseLink gibi) bu sınıftan kalıtım alan alt sınıflar olarak düşünülebilir. Yani JPA tek başına herhangi bir işlem yapamaz. Bu yüzden JPA kullanmak istediğinizde bir kütüphaneyi kullanmanız gerekmekte. Ben en çok kullanılan bir araç olan Hibernate ‘i kullanıyorum. Bu yüzden anlatımım Hibernate üzerinden olacaktır.

JPA ‘da tablo veya entity sınıflarının(tabloların sınıf karşılığı olan sınıflar) oluşturmak için 2 yöntem bulunmaktadır. Biri java sınıflarından veri tabanı tablolarının oluşturulması, diğeri de veri tabanı tablolarından java sınıflarının oluşturulmasıdır. Tabi ki her ikisinin de kullanım koşulları farklı, bu veri tabanına ya da java sınıflarına hakim olma oranına bağlıdır.

JPA ile yapabileceklerinizden bazıları:

  • Tablo ilişkileri,
  • Veri ekleme,
  • Veri silme,
  • Veri güncelleme
  • Veri çekme(Select sorguları)

Bu komutları JPA ‘in kendisi yönetmekte, siz sadece metotları kullanıyorsunuz ve esnek bir yapısı olduğundan size de JPQL(Java Persistence Query Language) yazmanıza izin veriyor. Bu Script dili gözünüzü korkutmasın, kullanımı SQL ‘e göre oldukça kolay ve güzel. Güzel diyorum çünkü sorgularınızı sınıf, nesne ve bu nesnelerin alt alanlarını kullanarak yazıyoruz.

Bize bu kadar avantaj sağlarken hiç dezavantajı yok mu derseniz, maalesef var. İyi bir data-modeli yapmadığınız halde arka kısımda oluşturulacak olan SQL sorguları oldukça uzun ve karmaşık olabiliyor. Bu yüzden dikkatli olmakta ve iyi tasarlamakta fayda var.

EOC(End Of Code)

Maven Nedir, Nasıl Kullanılır?

Merhaba arkadaşlar, bu yazımda size yakın zamanda kullanmaya başladığım oldukça faydalı ve kullanımı basit bir aracı anlatacağım. Maven, Ant ‘a bir alternatif olarak gösterilen aynı Ant gibi bir JDT(Java Development Tool) ‘dur. Ant ‘ın projeyle ilgili üst düzey bilgileri içermemesi ve kullanımı için oldukça uzun kodlar yazmayı gerektirmesi gibi nedenlerden dolayı Maven geliştirildi. Kısacası Maven ile Ant ‘ın yapabileceği her şey yapılabilir.

Ne işe yarar bu Maven?

Maven, proje geliştirirken proje içerisinde bir standart oluşturmamızı, geliştirme sürecini basitleştirmemizi, dokümantasyonumuzu etkili bir şekilde oluşturmamızı, projemizdeki kütüphane bağımlılığını ve IDE bağımlılığını ortadan kaldırmamızı sağlayan bir araçtır.

Maven ‘in faydalarını inceleyelim,

Kurulumda esneklik, Maven proje kalıpları sayesinde IDE bağımlılığı yoktur. Yeni bir proje oluşturacağınızda Maven proje kalıpları kullanabilirsiniz, bu kalıplar birer standart haline geldiği için tüm IDE ‘lerde desteklenmektedir.

Bağımlı kaynaklar, projede kullanılacak tüm kütüphaneler ve eklentiler POM(Project Object Model) dosyasından kolayca yönetilebilmektedir. Maven, kütüphane dosyalarını kendi repository sunucularında barındırır. Projede kullanmak istediğiniz kütüphane dosyalarını ilk olarak sizin local repository klasörünüzde arar, eğer bulamazsa kendi sunucularında arama yapar, eğer kendi sunularında da bulamazsa sizin tanımlayacağınız bir sunucu adresinden dosyayı sizin local klasörünüze indirir ve projeniz içerisinde kullanabilmenizi sağlar. Ayrıca bir kütüphane başka kütüphanelere bağımlıysa bu bağımlı olduğu kütüphaneleri de indirir ve projenize ekler.

Dokümantasyon, POM dosyası proje dokümantasyonu da içerebilmektedir. Yani proje hakkında bilgi edinmek için sadece bu dosyaya bakmak yeterli olacaktır.

Proje yapılandırma yönetimi, projenizin build ya da deploy yapılandırmalarını POM dosyasından yönetebilirsiniz. Sadece birkaç satır kodla bu yapılandırmalar arasında geçişler yapabilirsiniz. Mesela büyük çaplı bir proje, farklı sunucu sistemlerinde ya da farklı veri tabanlarında eş zamanlı olarak çalışması gerekebilir. Bunun için her güncelleme sırasında farklı yapılandırma ayarlarıyla bu sistemleri güncellememiz gerekir. Her sistem için yapılandırma dosyalarını baştan düzenlemek oldukça yorucu bir iş. Ancak POM dosyasında tanımlanacak yapılandırma ayarları işimizi görecektir. Sadece yapılandırma adını değiştirerek proje çıktısını farklı sistemlere uygun hale getirebilmekteyiz.

Sürüm yönetimi, her Maven projesinin bir grup id ‘si, bir yapı id ‘si ve bir de sürüm numarası vardır. Projenin farklı sürümlerini saklayabilir ve bunları daha sonra yeni projelerde kullanabiliriz.

Peki, nasıl kurarız bu Maven ‘i?

Maven kurulumu yapabilmek için ilk olarak ihtiyacınız olacak şey elbette JDK(Java Development Kit) ‘dır. Eğer JDK ‘e sahip olup olmadığınızı bilmiyorsanız, komut satırına java –version yazarak öğrenebilirsiniz.

Eğer JDK kurulu değilse http://www.oracle.com/technetwork/java/javase/downloads/index.html adresinden güncel JDK sürümünü kurabilirsiniz. Önemli bir nokta olarak Ortam Değişkenlerinde JAVA_HOME olduğundan emin olun.

Evet, şimdi sırada http://maven.apache.org/download.cgi adresinden güncel Maven sürümünü indirelim ve bu zip dosyasını Yerel disk C ‘nin altına çıkaralım.(C:\apache-maven-3.3.3 gibi)

Sırada birkaç ortam değişkeni eklemek var. Ortam değişkenlerine erişmek için Bilgisayarım ‘a sağ tıklayıp özellik diyoruz. Daha sonra Gelişmiş Sistem Ayarlarına tıklıyoruz.

1

Açılan pencerede Gelişmiş sekmesinin altından Ortam Değişkenlerine tıklıyoruz. Daha önce de söylediğim gibi Sistem Değişkenleri kısmında JAVA_HOME ‘un bulunması gerekmekte, özel bir durum oluşmadığı sürece JDK kurulumu sırasında bu otomatik olarak ekleniyor.

2

Ekleyeceğimiz tüm değişkenler Sistem Değişkenleri kısmında olacak, üst kısma eklemiyoruz.

İlk olarak Yeni bir değişken oluşturalım ve adına M2_HOME diyelim ve değerine de Maven ‘i çıkardığımız dizini verelim. (Örnek olarak C:\apache-maven-3.3.3\) Daha sonra kaydedelim.

3

Şimdi Path değişkenini seçelim ve düzenlemeye basalım.

4

Daha sonra değer kısmının sonunda noktalı virgül yoksa ekleyelim ve sonuna da %M2_HOME%\bin; ekleyelim. Son olarak da tamam diyerek değişlikleri kaydedelim.

5

Eğer her şey doğru gitmişse komut satırında mvn –version yazdığınızda karşınıza böyle bir şey gelecektir ve kurulum tamamlanmış olacaktır.

6

Maven ile basit bir örnek yapalım

Şimdi hemen basit bir proje oluşturarak nasıl kullanacağımızı görelim. Ben IDE olarak Intellij kullanacağım. Kurulum yapmak isteyenler https://www.jetbrains.com/idea/download/ adresinden indirebilir. Daha öncesinde Eclipse ‘de çalışıyordum ancak deneme şansı elde ederseniz ne kadar gelişmiş olduğunu görebilirsiniz. Tek dezavantajı ücretli olması, ancak 30 günlük deneme süresi var ve tabi ki biz sevgili öğrencileri de mutlu etmek için öğrenci mail adresiyle 1 yıllık lisans ücretsiz olarak veriliyor.

7

İlk olarak yeni bir web application projesi oluşturalım ve Maven ‘ı seçerek, sağ taraftan Maven kalıbını seçelim ve İleri diyelim.

8

Burada bizden GroupId ve ArtifactId girmemiz isteniyor. GroupId ‘i girerken dikkate almanız gereken birkaç durum var. GroupId, Projenin ait olduğu proje grubunu (com.kurukod) ve proje adını (ornekwebapp) içermelidir. ArtifactId ise projenin ana parçasının adını içermelidir yani projenin kendisi bu yüzden proje adını giriyoruz. Sonraki yazılarda Maven yardımıyla bir projeyi parçalar halinde geliştirerek bunları birleştirmeyi göreceğiz. Ancak bu sizin isteğinize bırakılmış bir şey, yani projeniz tek bir parçadan da oluşabilir. Evet, şimdi ileri diyelim ve sonraki sayfada hangi maven sürümünü kullanacağımızı seçelim. Intellij içerisinde gömülü bir Maven var. Peki neden onu kullanmıyoruz? Çünkü Maven ayarlarında (kurulum klasörünün içindeki settings.xml) değişiklik yapmamız gerekebilir ve birden fazla IDE ile çalışıyorsak tek bir Maven klasörüyle çalışmamız daha iyi olacaktır. Şimdi kurduğumuz Maven ‘i seçerek ileri diyelim. Eğer kurduğunuz Maven klasörünü burada göremiyorsanız sağdaki … butonundan ekleyebilirsiniz.

9

Şimdi de proje adını girelim ve projemizi oluşturalım.

10

Projemiz oluşturulduğunda kalıp indirilerek proje dizin yapısı oluşturulur. POM dosyamıza bakalım.

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.kurukod.ornekwebapp</groupId>
<artifactId>ornekwebapp</artifactId>
<packaging>war</packaging>
<version>1.0-SNAPSHOT</version>
<name>ornekwebapp Maven Webapp</name>
<url>http://maven.apache.org</url>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<finalName>ornekwebapp</finalName>
</build>
</project>

Her bir tag ‘ın bir işlevi vardır, bunları kısaca açıklamak gerekirse:

  • Project: Maven ‘in hangi versiyonları ve ayarları kullanacağını belirtir ve kök elemandır.
  • Model Version: Maven versiyonunu belirtir.
  • Packaging: Projemizin paketleme türünü belirtir. EAR, WAR, JAR gibi değerler alabilir.
  • Name: Projemizin adını belirtir.
  • Url: Projemizi paylaşmak istediğimizde veya sunucuya göndermek istediğimizde buraya yazacağımız adrese gönderilir.
  • Dependency: Projemizde kullanacağımız her bir kütüphane bir dependency yani bağımlılıktır. Her bir bağımlılığın bir proje çıktısı olduğunu varsayarsak sanırım içerisindeki groupId, artifactId ve version ‘un ne anlama geldiğini anlatmış olurum. Burada bilinmeyen tek tag, scope ‘dir.
  • Scope: Bir bağımlılığın projenin hangi yapılandırmasında kullanılacağını belirtir. Test, Debug, Run gibi değerler alabilir. Yazılması zorunlu değildir, sadece her yapılandırma sırasında kullanılmasını sağlamış oluruz.
  • Build: Projemizin yapılandırma ayarlarını ve kullanacağımız eklentileri tanımlayabileceğimiz kısımdır.

Ek bir bilgi olarak, projemizde özel kütüphaneler kullanmak isteyebilir ve bunları paylaşmak istemeyebiliriz. Bu durumda proje içerisine bu kütüphane dosyalarını ekler ve bunları POM dosyasında tanıtabiliriz, örneğin:

<dependency>
<groupid>javax.sql</groupid>
<artifactid>rowset</artifactid>
<version>1.0.1</version>
<scope>system</scope>
<systempath>${basedir}/lib/rowset.jar</systempath>
</dependency>

Burada ${basedir}, POM dosyasının bulunduğu dizini belirtir. Yani kök dizindir.

Maven komutları

  • clean: Projenin derlenmesi sırasında oluşan target klasörünün silinmesini sağlar.
  • Validate: Projenin target dosyasını siler ve daha sonra hatalı kısımları tarar.
  • Compile: Projeyi clean ve validate eder, daha sonra derler.
  • Test: Projeyi derler ve test sınıflarını çalıştırır.
  • Package: Projeyi testlerini yapar ve eğer hata yoksa projeyi paketler.
  • Verify: Projeyi paketler ve daha sonra bu paketlerin geçerliliğini kontrol eder.
  • İnstall: Projeyi doğruladıktan sonra repository sunucusuna yükler.
  • Deploy: Projeyi uygulama sunucusuna gönderir.

11

Komutlar şekilden de anlaşılacağı üzere birbiri içerisine gömülmüştür. Yani örnekle, deploy komutunu çalıştırmak tüm komutların sırasıyla çalışmasını sağlar. Bu komutları, komut penceresinden yazabilirsiniz. Modülleme gibi konuları vaktim oldukça açıklamaya çalışacağım.

EOC(End Of Code)

İlk Yazım

Merhaba arkadaşlar, benim adım Enes KURU. Bir yazılımcı adayıyım. Şuanda Sakarya Üniversitesi Bilgisayar Mühendisliği 2. sınıf öğrencisiyim. Daha yazılım ile uğraşmaya başlayalı fazla olmadı ancak, bir blog tutmanın önemi gerçekten büyük. Hem öğrenmek hem de öğrendiklerimin karşılığını vermek için bir blog açmaya karar verdim.

Üniversite hayatımın 2. döneminin başında bir şirkette part-time olarak çalışmaya başladım ve öğrenim hayatıyla çalışma hayatı arasındaki farkı daha erkenden görmeye başladım. Okul hayatıyla iş hayatının farkı küçümsenemeyecek kadar büyük olmakla beraber çoğu öğrencinin düşündüğü şey “Mezun olduktan sonra bir şirkete girip kendimi geliştiririm“.

Okul hayatı boyunca eğer kendinizi geliştirmezseniz mezun olduğunuzda da kendinizi geliştirmeye fırsat bulamazsınız. Her zaman bölüm derslerinin üstüne katmalısınız. Çünkü o derslerde size gösterilen buz dağının bulutlarının üstünde kalan kısmı. Evet bazı dersler sıkıcı, zor veya bölümle alakasız olabilir. Ya da hocanızdan kaynaklı problemler olabilir. Ancak bunlar her üniversite öğrencisinin atlatması gereken zorluklar.

Size derslerde öğretilenlere değil size uygunluğuna bakmalısınız 2. sınıf veya 3. sınıfa kadar artık sektörde ne iş yapacağınızı kafanızda belirlemiş olmanız gerekiyor. Seçtiğiniz alanda her zaman kendinizi geliştirmelisiniz. Okul hayatında kendine birşeyler katabilmiş yazılımcılar her zaman bir adım öndedir. Seçtiğiniz alanda staj yaparak (ama gerçekten staj yaparak) tecrübe edinmelisiniz. Staj yaptıkları yerlerden iş teklifi alan çok öğrenci var. Neden birisi de siz olmayasınız?

Eski bir hocam bir gün bana “Eğer bir işi kimse yapmadıysa seçebileceğin 2 yol vardır” demişti. İlki “kimse yapmadıysa ben nasıl yapayım?“, ikincisiyse “kimse yapmadıysa neden ilk ben yapmayayım?“. Evet yazılımda olsun hayatın diğer alanlarında olsun bir işte başarılı olmanın en önemli kriteri azimdir. Hedefine kararlı adımlarla yürümek size kalmış.

İyi kodlamalar…