Factory – Tasarım Kalıpları

Merhabalar, bu yazımızda Factory tasarım kalıbına değineceğim. Evet isminden de anlaşılacağı gibi nesne üretmeye yarayan bu tasarım kalıbı, Yaratıcı Tasarım Kalıplarından en çok kullanılanlarından biridir.Factory ‘nin Abstract Factory , Factory Method, Builder gibi tasarım kalıplarıyla benzerlik gösterir. Örneğim Factory Method tasarım kalıbını kullanarak yapacağım.

Senaryomuz şöyle olacak, Factory sınıfına vereceğimiz tipe göre bize İşletim Sistemi nesnesini versin ve elimizdeki işletim sisteminin önce açıp sonra kapatalım. Öncelikle bir IOperatingSystem adında interface ‘imiz olacak ve bu sınıfın gövdesi olmayan metodları yer alacak.(Java 8 ile interface’lerde metodlara başında default anahtar kelimesini koyarak gövdesini yazabilirsiniz.) Daha sonra bu interface’imizi implemente eden gerçek işletim sistemi sınıfları olacak. OperatingSystemFactory sınıfı ile de vereceğimiz tipe göre işletim sistemimizi yaratacağız. Şimdi biraz kodları görelim 🙂

IOperatingSystem.java

public interface IOperatingSystem {

    void start();

    void shutdown();

    void writeOperatingSystemName();
}

Ardından işletim sistemi sınıflarımızı kodlayalım.

Ubuntu.java

public class Ubuntu implements IOperatingSystem {
    @Override
    public void start() {
        System.out.println("Ubuntu started!");
    }

    @Override
    public void shutdown() {
        System.out.println("Ubuntu shutdown!");
    }

    @Override
    public void writeOperatingSystemName() {
        System.out.println("Ubuntu - Linux is the best OS");
    }
}

Windows.java

public class Windows implements IOperatingSystem {
    @Override
    public void start() {
        System.out.println("Windows started!");
    }

    @Override
    public void shutdown() {
        System.out.println("Windows shutdown!");
    }

    @Override
    public void writeOperatingSystemName() {
        System.out.println("Windows");
    }
}

Ardından Factory sınıfımızı ekliyoruz.

OperatingSystemFactory.java

public class OperatingSystemFactory {

    public static IOperatingSystem create(final String type) {
        if (type.equals("UBUNTU")) {
            return new Ubuntu();
        } else if (type.equals("WINDOWS")) {
            return new Windows();
        } else {
            throw new RuntimeException("Operating System not found!");
        }
    }

}

Ve son olarak Main sınıfımızda İşletim Sınıfımızı yaratalım.

Main.java

import com.patterns.factorymethod.IOperatingSystem;
import com.patterns.factorymethod.OperatingSystemFactory;

public class Main {

    public static void main(String[] args) {
        IOperatingSystem operatingSystem = OperatingSystemFactory.create("UBUNTU");
        operatingSystem.start();
        operatingSystem.shutdown();
        operatingSystem.writeOperatingSystemName();
    }
}

Çıktı:
Ubuntu started!
Ubuntu shutdown!
Ubuntu – Linux is the best OS

Evet görüldüğü gibi Factory sınıfımıza tip vererek istediğimiz İşletim Sınıfı nesnemizi yarattık ve metotlarını kullandık. Artık kurduğumuz bu sisteme yeni bir İşletim Sınıfı eklemek daha kolay ve hızlı olacak.

Şimdilik bu kadar görüşmek üzere…

Bir fıkra hatırlıyorum. Adam doktora gider. Kederli olduğunu söyler. Hayat onun için zor ve zalimdir. Tehtitkâr bir dünyada kendini yapayanlız hissettiğini söyler. Doktor tedavisi basit der. Büyük palyaço Pagliacci şehrimize geldi. Git onu gör seni neşelendirir. Adam göz yaşlarına boğulur. Ama doktor der Pagliacci benim zaten.(Watchmen 2009)

Singleton – Tasarım Kalıpları

Merhaba, evet kendisi en çok kullanılan tasarım kalıbı sanırım. Elinizi attığınız her projede kullanılan bir kalıp. Singleton, Tekillik olarak çevrilebilir. Bu tasarım kalıbı, bir sınıftan sadece bir nesne oluşturulması ve bu nesnenin tüm sistemlerde kullanılması durumunda ihtiyaç duyulur. Şimdi bir Singleton örnek kodunu görelim.

Singleton.java

package com.patterns.singleton;

/**
 * Created by ufuk on 19.8.2016.
 */
public class Singleton {

    private static Singleton instance = null;
    private static Object lock = new Object();

    private Singleton() {
        //private constructor
    }

    public static Singleton instance() {
        if (instance == null) {
            synchronized (lock) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

    public void println() {
        System.out.println(this);
    }
}

Örneği incelediğimizde bir Singleton sınıfında olması gerekenler:
1- Private bir constructor, böylece bu sınıftan new operatörü ile nesne oluşturulması önüne geçilir.
2- Sadece bir nesne oluşturulmasını istediğimiz için nesneyi static olarak tanımlama
3- Sadece bir nesne oluşturabilmek için static olarak tanımlanmış bir instance() metodu

Yukarıdaki kodda instance metodunda  synchronized kullanarak tek bir nesne oluşturulmasını garanti etmiş olduk. Bu double checking ‘in nedeni Java‘nın  multi threaded bir sistem olması durumu. Main sınıfımızda da for içinde instance metodunu 10 kere çağıralım.

Main.java

package com.patterns;

import com.patterns.singleton.Singleton;

public class Main {

    public static void main(String[] args) {
        for (int i=0; i<10; i++) {
            Singleton.instance().println();
        }
    }
}

Çıktı : 
com.patterns.singleton.Singleton@610455d6
com.patterns.singleton.Singleton@610455d6
com.patterns.singleton.Singleton@610455d6
com.patterns.singleton.Singleton@610455d6
com.patterns.singleton.Singleton@610455d6
com.patterns.singleton.Singleton@610455d6
com.patterns.singleton.Singleton@610455d6
com.patterns.singleton.Singleton@610455d6
com.patterns.singleton.Singleton@610455d6
com.patterns.singleton.Singleton@610455d6

Evet, görüldüğü gibi Singleton sınıfından sadece bir nesne oluştuğunu görebiliyoruz. Ancak Singleton tasarım kalıbının günümüzde Anti-Pattern durumu var. Bunun sebebi de sınıf constructor‘ının private olmasından dolayı, singleton nesnelerinin zor test edilmesinden dolayıdır.

Şimdilik bu kadar, görüşmek üzere…

O mükemmel değil. Sen de mükemmel değilsin. Asıl soru birbiriniz için mükemmel olup olmadığınız. (Good Will Hunting)

Tasarım Kalıpları Giriş

Merhabalar, bu yazımla birlikte tasarım kalıpları yazı dizisine başlamış olacağım.(Tasarım prensipleri içinde belki ayrı bir yazı dizisi yapabilirim.) Tasarım kalıpları için bir tanımlama yapmak gerekirse; yazılımdaki tekrar eden sorunları, problemleri çözebilmek için tekrar kullanılabilir, esnek yapıda olan bir veya birden fazla sınıftan oluşmuş programlar denilebilir. Tasarım kalıpları tecrübelere dayanır. İlla projelerinizde kullanmanıza gerek yok. Ancak yazılımcılar arası ortak bir dildir tasarım kalıpları. Hangi programlama dilinde geliştirme yaparsanız yapın, yazılımcı olarak yazdığınız kodu başka yazılımcılara anlatırken burada ‘Singleton‘ kalıbını kullandım, burada ‘Strategy‘ kalıbını kullandım, dediğinizde anlatmak istediğiniz neyse karşı tarafa rahatça ulaşacaktır.

Ancak sırf olsun diye değil, ihtiyaçların sorgulanıp, kullanılacak tasarım kalıbına ne kadar gerekli olduğu sonucu baştan çıkarılması geliştirme süresine doğrudan etki edecektir. Aksi halde yerli yersiz kullanılan tasarım kalıpları mimarinizi kötü yönde etkiler.

Tasarım kalıpları temelde 3 kategoriye ayrılır.

Oluşturucu Tasarım Kalıpları
-Factory, Factory Method, Singleton, Builder vb.

Yapısal Tasarım Kalıpları
-Facade,  Adapter, Proxy vb.

Davranışsal Tasarım Kalıpları
-Iterator, Observer, Strategy vb.

Bu yazıyla tasarım kalıplarına girişi basitten yapmış olduk. Sonraki yazılarda örnekler üzerinden çokça kullanılan tasarım kalıplardan ilerleyerek devam edeceğim. Görüşmek üzere..

 
İnsan sevdiğini öldürür diye bir söz vardır ya. Aslında bakın, insanı öldüren hep sevdiğidir. (Fight Club)

SpringBoot – 3 (Thymeleaf)

Selamlar, bu yazımızda Thymeleaf ‘den bahsedeceğim. Spring ile entegresini yapıp bir kaç özelliğini kullanacağım. Thymeleaf, açık kaynak olarak geliştirilen, Servlet tabanlı çalışan bir template engine‘ dir. Daha önce eğer JSP kullanarak bir şeyler yaptıysanız Thymeleaf veya benzeri FreeMarker, Apache Velocity gibi diğer template engine‘lerin  avantajlarını daha iyi anlayabilirsiniz. Ön yüzde  size gerçekten esneklik sağlamakta.  Buradan daha detaylı bilgi alabilirsiniz. Şimdi SpringBoot ile entegresine geçelim. İlk önce bağımlılığımızı ekleyelim. (Bu yazımda da daha önceki projemden ilerliyorum.)

pom.xml

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

Ardından resources klasörü içindeki templates klasörüne index.html dosyamızı ekleyelim.

index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8" />
    <title>Thymeleaf Examples</title>
</head>
<body>
Test
</body>
</html>

Sonrasında HomeController sınıfımızı aşağıdaki gibi düzenleyelim.

HomeController.java

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

/**
 * Created by ufuk on 8.8.2016.
 */
@Controller
public class HomeController {

    @RequestMapping(value = "/", method = RequestMethod.GET)
    public String displayHomePage(Model model) {

        return "index";
    }
}

Controller‘daki metodumuz da olusturduğumuz html dosyanın adını return ediyoruz. Ardından projeyi run edip http://localhost:8080/SpringGiris/ istek yaptığımızda index.html dosyamızın içeriği gelmektedir. Bu kadar kolay işte 🙂 Şimdi basit olarak for, if ve attribute yazdıralım ekrana.

Controller sınıfımızı düzenleyelim.

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

/**
 * Created by ufuk on 8.8.2016.
 */
@Controller
public class HomeController {

    @RequestMapping(value = "/", method = RequestMethod.GET)
    public String displayHomePage(Model model) {

        List<String> uuids = getUUIDList(10);

        model.addAttribute("list", uuids);
        model.addAttribute("isEmpty", uuids.isEmpty());
        model.addAttribute("fullName", "Ufuk Halis");

        return "index";
    }

    private List<String> getUUIDList(int limit) {
        List<String> uuids = new ArrayList<>();
        for (int i = 0; i < limit; i++) {
            uuids.add(UUID.randomUUID().toString());
        }
        return uuids;
    }
}

Rastgele değerler üretip bir liste oluşturdum. Daha sonra bu listeyi ve başka değerleri Metodumuzun model parametresine addAttribute şeklinde ekledik. Artık View kısmından bu değerlere ulaşabiliriz. index.html dosyamızı da düzenlersek.

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8" />
    <title>Thymeleaf Examples</title>
</head>
<body>
<h1 th:text="'Full Name : ' + ${fullName}"></h1>

<h1>UUIDS</h1>
<p th:each="item : ${list}" th:text="${item}"></p>

<p th:if="${isEmpty}" >Empty</p>
<p th:if="${!isEmpty}" >Not Empty</p>

</body>
</html>

Evet, controller da set ettiğimiz attribute‘lere ulaşıp ekrana bastık, each ile listemiz içinde döndük, if ile de koşul durumunu gördük. Thymeleaf ‘in bu özelliklerini JSP kodlarken JSTL ile de yapabiliriz. Ancak tabi Thymeleaf ‘in ayıran özelliklerini fragment‘lar, SpringSecurity ile olan ilişkisi, hazır metotları vb. özelliklerini ilerleyen yazılarda zamanı geldikçe değineceğim. Şimdilik bu kadar. 🙂

Ya İyi Olarak Ölürsün, ya da kötüye dönüşecek kadar uzun yaşarsın
(The Dark Knight – 2008)

SprinBoot – 2 (Hibernate)

Merhaba, bu yazımızda SpringBoot veritabanı işlemleri ile devam edeceğiz. Önceki yazımdaki projeyi kullanacağım. SpringBoot ile veritabanı ayarları sizde görünce hak vereceksiniz oldukça kolay.

Yazımda Hibernate falan üzerinde çok durmayacağımdan o yüzden entity sınıflarındaki notasyonların hepsini açıklamayacağım. Belki hibernate için ayrı bir yazıda anlatabilirim. Bu yazımdaki amaç SpringBoot ile bu işlemleri yapmak.

Örneğimizde User ve Address adında iki entity sınıfımız olacak ve uygulama ayağı kalkma anında veritabanımıza kayıtlar ekleyip okuyup sonrasında sileceğiz.
Öncelikle pom.xml dosyamıza gerekli bağımlılıkları ekleyelim.

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
   <scope>runtime</scope>
</dependency>

Veritabanı olarak ben MySQL kullanıyorum. Siz herhangi bir veritabanı kullanabilirsiniz. Ona göre connector bağımlılığınızı eklemeniz gerekir.

Ardından application.properties dosyamızı gerekli eklemeleri yapalım.

spring.datasource.url = jdbc:mysql://localhost:3306/boot_hibernate_db
spring.datasource.username = root
spring.datasource.password = root
# Keep the connection alive if idle for a long time (needed in production)
spring.datasource.testWhileIdle = true
spring.datasource.validationQuery = SELECT 1
# Show or not log for each sql query
spring.jpa.show-sql = false

# Hibernate ddl auto (create, create-drop, update)
spring.jpa.hibernate.ddl-auto = create-drop
# The SQL dialect makes Hibernate generate better SQL for the chosen database
spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5Dialect
spring.jpa.properties.hibernate.enable_lazy_load_no_trans=true

Evet, veritabanı yolumuzu, kullanıcı adı ve parola bilgilerini, Spring jpa ile ilgili ayarlarımızı bu şekilde yapabiliyoruz. Ardından User ve Address entity ‘lerimiz ekleyelim. Entity notasyonu ile etiketlenen sınıflar Hibernate tarafından tablo olarak dönüştürülür. Sınıf elemanları da kolon olarak dönüştürülür.  Bizim User ile Address arasında OneToMany ilişkisi olacak, bir kullanıcının birden fazla adresi olabilir anlamına geliyor bu da.

User.java

import javax.persistence.*;
import java.io.Serializable;
import java.util.List;

/**
 * Created by ufuk on 10.8.2016.
 */
@Entity
public class User implements Serializable{

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private long id;
    private String firstName;
    private String middleName;
    private String lastName;

    @OneToMany(mappedBy = "user")
    private List<Address> addresses;

    public void setAddresses(List<Address> addresses) {
        this.addresses = addresses;
    }

    public List<Address> getAddresses() {
        return addresses;
    }

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getMiddleName() {
        return middleName;
    }

    public void setMiddleName(String middleName) {
        this.middleName = middleName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
}

Address.java

import javax.persistence.*;
import java.io.Serializable;

/**
 * Created by ufuk on 10.8.2016.
 */
@Entity
public class Address implements Serializable{

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private long id;
    private String address;
    @ManyToOne
    @JoinColumn(name = "user")
    private User user;

    public void setId(long id) {
        this.id = id;
    }

    public long getId() {
        return id;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getAddress() {
        return address;
    }
}


Projeyi bu haliyle çalıştırdığımızda gerekli tablolar belirttiğimiz veritabanında oluşacaktır. Şimdi ise Repository interface‘lerimizi oluşturalım. Repository interface‘lerimiz sayesinde CRUD işlemlerini gerçekleştireceğiz.

UserRepository.java

import com.ufuk.entity.User;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

/**
 * Created by ufuk on 10.8.2016.
 */
@Repository
@Transactional
public interface UserRepository extends CrudRepository<User, Long> {
}

AddressRepository.java

import com.ufuk.entity.Address;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

/**
 * Created by ufuk on 10.8.2016.
 */
@Repository
@Transactional
public interface AddressRepository extends CrudRepository<Address, Long> {
}

Evet görüldüğü gibi Repository notasyonu ile etiketleyip CrudRepository sınıfından extend ediyoruz.

Ardından Main sınıfımızı düzenleyelim.

SpringBootGirisApplication.java
import com.ufuk.entity.Address;
import com.ufuk.entity.User;
import com.ufuk.repository.AddressRepository;
import com.ufuk.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import java.util.Arrays;

@SpringBootApplication
public class SpringBootGirisApplication implements CommandLineRunner{

   @Autowired
   UserRepository userRepository;

   @Autowired
   AddressRepository addressRepository;

   public static void main(String[] args) {
      SpringApplication.run(SpringBootGirisApplication.class, args);
   }


   @Override
   public void run(String... strings) throws Exception {
      Address address = new Address();
      address.setAddress("Arlington Street, 1578");

      User user = new User();
      user.setFirstName("Ufuk");
      user.setLastName("Halis");
      user.setAddresses(Arrays.asList(addressRepository.save(address)));
      user = userRepository.save(user);

      readData();

      userRepository.delete(user);

      readData();

   }

   private void readData() {
      Iterable<User> userIterable = userRepository.findAll();
      if (!userIterable.iterator().hasNext()) {
         System.out.println("No data found!");
      }
      for (User u : userIterable) {
         System.out.println("First Name : " + u.getFirstName());
         System.out.println("Last Name : " + u.getLastName());
         for (Address a : u.getAddresses()) {
            System.out.println("Address : " + a.getAddress());
         }
         System.out.println("*******************************");
      }
   }
}

Evet, görüldüğü gibi basit olarak bir kullanıcı ve adres ekledik, okuduk ve sildik ve bunu yarattığımız Repository sınıflarıyla yapabildik. Repository sınıflarımıza kendi metot gövdelerimizi ekleyebiliriz. Örneğin bir kullanıcıyı firstName alanına göre bulmak istersek şu şekilde bir metot gövdesi eklememiz yeterli.

User findByFirstName(String firstName);

Spring Data metot isminden gerekli sorguyu yapacak ve sonucu döndürecektir. Custom query oluşturmak için de metodumuzu Query notasyonu ile etiketlemek yeterli. Ardından içine query‘imizi yazabiliriz.

Uygulamayı çalıştırdığımızda aşağıdaki ekran görüntüsü gibi bir çıktı alacağız.Ekran Alıntısı.PNG

Evet, bu yazımızda bu kadar. Basit olarak SpringBoot ile bir veritabanına bağlandık, kayıt sildik ekledik vs.  Sonraki yazılarda görüşmek üzere…

Bu ve bundan sonraki yazıları filmlerden alıntılar ile bitireceğim artık, kullandığım bitiriş cümlesi çok beğenilmedi arkadaşlar tarafından 🙂

-Kaşığı eğmeyi boşa deneme. Bu imkansızdır. Bunun yerine sadece gerçeği anlamaya çalış.Tamam mı?
-Gerçek nedir?
-Aslında bir kaşık yok. Eğilen sadece kendinsin.
(Matrix)

SpringBoot – Giriş

Merhabalar, uzun bir aradan sonra son zamanlarda çok içli dışlı olduğum bir framework’ten bahsedeceğim. SpringBoot. Evet Spring framework’u biliyoruz. Kendisi Java dünyasında defacto standartı olarak kabul edilir. Dependency Injection ve IOC bu framework’un temel taşlarıdır. Spring framework’te konfigürasyon işlemleri ilk başlarda XML üzerinden hep yürürdü. Tabi zamanla annotation bazlı konfigürasyonlarda popüler oldu. Ancak bazı durumlarda Spring agile olamama durumu, yaygınlaşan microservices olayları SpringBoot’un doğmasına neden oldu. Evet SpringBoot ile çok hızlı, fazla konfigürasyon işlerine girmeden projeler oluşturabilir. Jar ve War çıktıları alabilirsiniz. Bu yazımda Intellij Idea üzerinde bir SpringBoot projesi oluşturup ayağı kaldıracağız.

Evet Ide’mizi açtıktan sonra New Project deyip Sol taraftan Spring Initialzr’ı seçip ilerliyoruz.

new_project

Ardından gelen ekran projemizle ilgili konfigürasyonları yapıyoruz. Type olarak Maven veya Gradle, dil olarak Groovy, Java ve Kotlin, çıktı olarak Jar veya War seçebilirsiniz.

new_project2.png

Daha sonraki gelen ekranda ihtiyacımız olan bağımlılıkları projemize seçip ekleyebiliriz. Bizim uygulamamız basit bir uygulama olacağı için sadece Web bağımlılığını ekliyorum.

new_project3.png

Devam edip Finish dediğimizde aşağıdaki resimdeki gibi bir proje yapısı ve bir adet main sınıfımız geliyor.

project_folder.png

src klasörü altında java class‘larının yer aldığı java klasörü ve resources klasörü bulunmakta. pom.xml ‘den anlayabileceğimiz gibi bizim projemiz Maven tipinde. resources içinde application.properties(Konfigürasyonların yapıldığı dosya kendisi.), static(js,images,css vb.) ve templates(html dosyalarımızı koyacağımız yer). SpringBoot Thymeleaf ile oldukça uyumlu bende projelerde Thymeleaf tercih ediyorum. Siz başka bir template engine kullanacağınız gibi sadece jsp de kullanabilirsiniz.

Bu şekilde projemizi run ettiğimizde ayağı kalkacaktır. Ancak herhangi bir controller vs oluşturmadığımız için not found tarzında bir hata alırız. Öncelikle application.properties dosyamıza aşağıdaki kodları ekleyelim.

server.contextPath=/SpringGiris
server.port=8080

Gördüğünüz gibi port numarası ve context path atamasını böyle yapabilirsiniz. Sonra HomeController adında bir sınıf ekleyelim. İçeriğide aşağıdaki gibi olsun.

package com.ufuk;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

/**
 * Created by ufuk on 8.8.2016.
 */
@Controller
public class HomeController {

    @RequestMapping(value = "/", method = RequestMethod.GET)
    public ResponseEntity<String> displayHomePage(Model model) {

        return new ResponseEntity<>("SpringBoot Merhaba", HttpStatus.OK);
    }
}

Evet daha önceden Spring ‘ de bir controller yazdıysanız hiçbir farkı yok. http://localhost:8080/SpringGiris/ adresine isteğimizi atınca sonuç olarak aşağıdaki ekranı alıyoruz.

son.png

Evet şimdilik bu kadar. Sonraki SpringBoot yazılarında Veritabanı bağlantıları, Spring Data, SpringSecurity vs kullanarak aynı projeyi genişleteceğim. Görüşmek üzere…

Test edilmeyen kod tuhaflaşır…

 

Mercurial – Versiyon Kontrol Sistemi

Bu yazımda versiyon kontrol sistemlerinden biri olan Mercurial nedir nasıl kullanılır gibi bilgiler vereceğim.
VCS(Version control system), yazılımcıların bir proje üzerinde ortak bir şekilde çalışabilmesine olanak sağlayan, gerek duyulduğunda eski kodlara ulaşılabilmesine yardımcı olan bir sistem olarak tanımlayabiliriz. En bilindikleri Git, SVN, Mercurial şeklinde gider. Ama şuan en popüler olarak kullanılan dünyada ve ülkemizde Git‘ dir.
Bense gerek alışkanlık gerekse daha kolay rahat olduğum Mercurial sistemini bu yazımda nasıl kullanıldığını bir örnek ile açıklayacağım.

Öncelikle sitesinden güncel sürümü işletim sistemimize uygun olanı indirelim. Link : https://www.mercurial-scm.org/
Projeyi atacağım yer Bitbucket sitesidir. Avantajı olarak hem Git hem de Mercurial destekleyebilmesi ve ayrıca private(özel-gizli) repo oluşturabilmeyi olanak sağlamaktadır. Link : bitbucket.org

IDE olarak Eclipse Mars‘ı kullanıyorum. Size Netbeans veya Intellij seçebilirsiniz. İndirdiğimiz dosyayı kurduktan sonra terminal ve cmd ‘ yi açarak hg –version komutunu kullanarak kurulup kurulmadığını görebiliriz. Ardından Eclipse marketplace ‘ e girerek resimdeki gibi Mercurial plugin’i yüklüyoruz.

1

Ardından bitbucket sitesinde Create Repository ‘ den yeni bir repo oluşturuyoruz.

2

Sonra Eclipse ‘ te yeni bir proje oluşturalım. Oluşturduktan sonra proje üzerine sağ tıklayıp Team->Share Project seçelim.

3

Seçeneklerden Mercurail seçip işlemi bitirelim. Artık bir projemize Mercurial‘ı uyguladık ve hemen dikkatimizi çeken projemizin üstünde bir ikon geldi. Bu commit ‘ lemediğimiz dosyaların var olduğu anlamına gelmektedir.

Bu sistem şöyle işler. Bir uzak repomuz vardır bir de local repomuz vardır ve bir de çalıştığımız workspace. Bir dosya eklersek, çıkarırsak veya değiştirirsek bunları commit’lemediğimiz sürece değişiklikler workspace’de kalır. Commitleyince local repomuz güncellenir. Ardından bu commit’i pushlarsak uzak repomuz güncellenir. En basit mantık böyle işlemektedir. Yaptığımız değişikliği Revert seçeneğiyle geri alabiliriz. Ancak commit yapmadığımız sürece revert yapabiliriz.

Ardından Eclipse->Window->Show View->Other kısmına gelip Mercurial Repositories seçelim. Aşağıdaki gibi bir ekran gelicektir.

4

Kırmızı alanla belirtilen yeri seçelim ve gelen ekranı bitbucket username, password ve repo ‘ url’i girin.

5

Ardından Team->Synchronize With seçeneğini seçip gelen ekranda combobox’tan girdiğimiz url’i seçip Finish diyelim ve şuan projemiz uzak repo ile bağlantılı hale getirdik.

Ardından basit bir Java main sınıfı projemize dahil edelim.

6

Ardından Team->Commit diyelim. Bir commit mesajı verip işlemi tamamlayalım. Bunu yaptıktan sonra projemiz üzerindeki o siyah ikon gitmiş olacak ve yerine 1 veya yaptığımız commit sayısına bağlı olarak bir sayı gelecektir. Synchronize tab’i altında da aynı işlemleri gerçekleştirebilirsiniz.

7

Ardından yine aynı yeri kullanarak bu sefer Push seçeneğini seçelim. Evet şimdi bitbucket hesabınızı kontrol ettiğinizde dosyları orada görebileceksiniz.

8

Repo link : https://bitbucket.org/uhalis/mercurialtest/

Son olarak önemli olan bir dosya dan bahsedeceğim. .hgignore isimli dosya, commit-push ‘ a girmesini istemediğimiz klasör ve dosya tanımlamalarını içerir. Genel olarak Eclipse kullanırken .settings klasörü, bin klasörü .classpath ve .project dosyalarını atmamıza gerek yoktur. Bunlar her pc’ye göre değişebileceğinden exclude edilir. Bizim için önemli olan kod ve lib’lerdir.
Bir dosyayı ignore etmek için dosya üzerine sağ tıklayıp Team->Ignore seçebiliriz. Ayrıca .hgignore dosyasını da ignore edebiliriz.

Evet bu yazımda Mercurial nasıl kullanılır hakkında elimden geldiğince yazdım. Sonraki yazılarda görüşmek üzere..

Test edilmeyen kod tuhaflaşır…

Kod Analiz Aracı : Source Monitor

Uzun bir aranın ardından tekrar yeni bir yazıyla geri dönüş yapıyorum. Bir blog tutmak sadece tutmak değil aslında güncel tutabilmek içeriği gerçekten zormuş. Bunu anladım. Neyse.. 🙂
Bu yazımızda Source Monitor isimli bir tool hakkında bildiklerimi size aktarmaya çalışacağım.
Evet, başlıkta ta belli ne olduğu programın, bir kod analiz aracı kendileri. Ücretsiz bir araçtır. Rahatlıkla indirebilirsiniz.
İndirme Link : http://www.campwoodsw.com/SourceMonitorUpdateV350.zip
Sitesi : http://www.campwoodsw.com/sourcemonitor.html

Source Monitor, bize yazdığımız kod ile ilgili bilgiler verir. Kod satır sayısı, metot bazlı karmaşıklık oranı, sınıf sayısı vb. metrikler bulunur. Bunları basit bir şekilde bize gösteren bir arayüze sahiptir. Source Monitor sayesinde, kodu iyileştirirken nerelere dikkat etmemiz gerektiğini, öncelik verirken nereden başlayacağımızı bir yol haritası çizebiliriz.

İndirme linkini kullanarak programı indirelim ve ardından zip dosyasını istediğiniz yere açın. Sonra SourceMonitor.exe uygulamasını açın. Aşağıdaki gibi bir görüntü karşılayacaktır bizi.

1

Ardından File -> New Project yapalım. Bize projenin kaynak kodunun dilini seçmemizi isteyen bir ekran geliyor. Ben burada Java’yı seçip ilerliyorum.

2

Sonra bu Source Monitor projesine vereceğimiz ismi ve kayıt edileceği yeri seçiyoruz.

3

Ardından projenizin source package’nın yolunu seçiyoruz.

4

Ardından çıkan ekrandaki tüm seçenekleri seçerek ilerleyelim. (Oradaki seçeneklerde, Modifiye edilmiş karmaşıklık metriğini kullan, boş satırları sayma ve Baş ve Sondaki yorum satırlarını sayma seçenekleri bulunuyor.)

5

Sonraki aşama Source Monitor ile ilgili bir durum, kayıt dosyasının formatını size soruyor. Ben New Source Monitor Project format olanı seçiyorum.

Sonra ilk Checkpoint olarak ayarlıyoruz ve buna bir isim veriyoruz. Source Monitor ‘ ün de default olarak yaptığı ve çoğunlukla kullanılan Baseline olarak bırakıyorum ben. Siz tabi ki istediğiniz ismi koyabilirsiniz.

6

Ardından son diyoruz ve son bir ekran bizi karşılıyor. Bu ekranda son olarak düzenlemelerinizi yapabilirsiniz. İşleme girmesini istemediğiniz sınıfları çıkarabilir veya yeni sınıflar ekleyebilirsiniz.

7

Ardından OK diyoruz ve Source Monitor hızlı şekilde bize sonuçları getiriyor. İlk gelen ekran aşağıdaki gibi

8

Evet ilk ekran gördüğünüz gibi kod hakkında genel bir bilgi veriyor. Satır sayısı, max. karmaşıklık, metot/sınıf oranı, Sınıf sayısı vb. ifadeler bulunmakta. Satıra çift tıkladığımızda ise bizi sınıf bazlı bir görünüm karşılamaktadır.

9

Sınıf ayrıntısı için de sınıflara çift tıkladığımızda, o sınıfla ilgili detaylı bilgiye sahip oluyoruz.

10

Görüldüğü gibi Source Monitor güzel bir şekilde projeyle ilgili herşeyi vermektedir.

Tekrar Baseline kısmına gelip sağ tıklayıp Display Checkpoint Kiviat Graph diyelim. Gördüğünüz bu grafik aslında projenin genel halini göstermekte ve amacımız yeşil alanın içerisinde kalmayı başarmak.. 🙂

11

Son olarak ise projenizi geliştirmeye devam ettikten sonra tekrar aynı projeyi Source Monitor ‘ de devam etmek için Sol üst köşeden New Checkpoint seçeneğini seçip (size önceden gösterdiğiniz yoldaki sınıfları ekleyerek tekrar soracaktır) Checkpoint’inize bir isim verip OK dedikten sonra hemen Baseline ‘nın üstüne yeni bir satır eklenir. Böylelikle Checkpoint ‘ lerinizi karşılaştırabilirsiniz.

12

Evet geldik son sözlere, bu yazımda çok yararlı bulduğum Source Monitor isimli aracı size tanıtmak ve anlatmak istedim. Umarım faydalı olur. Sonraki yazılarda görüşmek üzere..

Test edilmeyen kod tuhaflaşır…

Maven projelerde jar dosyası nasıl eklenir?

Merhaba, bu yazımda bir jar dosyasının Maven projelerde nasıl ekleneceğini kısaca anlatacağım.
İlk olarak nereden çıktı bu diyebilirsiniz zaten uzak repo’dan Maven bağımlılıkları indiriyor diyebilirsiniz. Evet indiriyor, peki ya kullanacağınız jar uzak repo ‘ da yoksa veya önceden yazdığınız bir kütüphaneyi projenize eklemek isterseniz ne olacak? Evet, bu durumu şimdi sırasıyla açıklayalım.

Öncelikle şu linkteki jar dosyasını indirelim. (http://code.google.com/p/kaptcha/downloads/list) Ben bu jar dosyası üzerinden gideceğim. Siz istediğiniz jar dosyasını kullanabilirsiniz tabi ki.

Command line üzerinde aşağıdaki komutu kendinize göre düzenleyip yazınız.

mvn install:install-file -Dfile=c:\desktop\ufuk\kaptcha-{version}.jar -DgroupId=com.google.code -DartifactId=kaptcha -Dversion={version} -Dpackaging=jar

Dfile, indirdiğimiz jar dosyasının yolunu veriyoruz. {version} yerine – kaptcha-2.3.2.jar – jar dosyasının biliyorsanız versiyonunu geçiniz. Bilmiyorsanız 1.o değerini verebilirsiniz.

DartifactId, projenin ismini verebilirsiniz.

Dversion, {version} yerine verdiğiniz değeri veriniz.

Yazdığımız komutu çalıştırdığımızda BUILD SUCCESSFUL çıktısını verdiyse sorun yok demektir.
ve son olarak pom.xml dosyasına bağımlılığımızı ekleyebiliriz.

 <dependency>
      <groupId>com.google.code</groupId>
      <artifactId>kaptcha</artifactId>
      <version>2.3.2</version>
 </dependency>

İşte bu kadar, herhangi bir jar dosyasını önce local repomuza ekledik ve bağımlılık olarak tanımladık.

Sonraki yazılarda görüşmek üzere!!

Test edilmeyen kod tuhaflaşır…

Java 8 Lambda Nedir ve Nasıl Kullanılır?

Merhaba, bu bloga 2.yazım olarak JDK 8 ‘ de adını vermiş (Project Lambda), JDK 8 ‘ in getirdiği en önemli özelliklerden biri olan Lambda ‘ ların ne olduklarını ve basit olarak nasıl kullanıldıklarını anlatacağım.

 

Lambda , programlama dili çerçevesinde Lambda, anonim tekil görevler olarak değerlendirilebilir. Lambda deyimleri (Lambda fonksiyonları da denebilir), referans verilebilir ve tekrar tekrar kullanılabilirdir. [1] Temelde belli bir giriş değerine karşılık bir sonuç üretirler.

Kullanımını örnekler üzerinden devam edelim..

Kod 1 : Döngü

Basit bir string listesi içindeki verileri konsola yazdırırken aşağıdaki gibi bir yol izleriz.


String[] strArray = {"Bruce Wayne", "Jason Todd", "Dick Grayson", "Tim Drake", "Barbara Gordon"};
List characters = Arrays.asList(strArray);
for (String character : oyuncular) {//Bildigimiz for dongusu
System.out.println(character);
}

Lambda’lar ile for döngüsünü aşağıdaki şekilde olmaktadır.


characters.forEach((character) -> System.out.println(character));

Kod 2 : Limit
Listemizde 5 eleman bulunmakta biz sadece 3 tanesini yazdırmak istersek aşağıdaki kod tam da istediğimiz işi yapacaktır.


characters.stream()
.limit(3)
.forEach((character) -> System.out.println(character));

Kod 3 : Sıralama
İsme göre sıralama yapmak istersek aşağıdaki gibi bir kod yazılabilir.


List sortedCharacters = characters
.stream()
.sorted((c1, c2) -> (c1.compareTo(c2)))
.collect(toList());

Kod 4 : Thread
Normal olarak yazdığımız thread aşağıdaki gibi tek satıra indirgenmektedir.


new Thread(new Runnable() {
@Override
public void run() {
System.out.println("Lambda!!");
}
}).start();

//lambda ‘ lar ile


new Thread(() -> System.out.println("Lambda!!")).start();

 

Evet çok basit örnekler ile lambda ‘ ların kullanımı bu şekilde. Lambda ‘ lar JDK 8 ile gelmektedir bu yüzden sisteminizde JDK 8 yüklü olması gerekiyordu.
Ancak retrolambda adı verilen proje sayesinde, lambda ‘ ları JDK 5,6 ve 7 versiyonlarında da kullanılabilmesine olanak tanıyor. Proje linki : https://github.com/orfjackal/retrolambda
İlerleyen zamanlarda bu kütüphanenin nasıl kullanıldığına dair bir yazı yazmayı düşünüyorum.

Şimdilik bu kadar.. 🙂

Test edilmeyen kod tuhaflaşır…