Tag Archives: Design Pattern

Genel Yazılım ve Sistem Mühendisliği

Süzgeç Tasarım Deseni

Belirli bir nesne grubunun bir veya daha fazla kritere göre filtrelenebilmesini sağlayan yapısal tasarım desenidir. Tanımdan da anlaşılacağı üzere filtreleme işlemi tekil veya zincir halinde gerçekleştirilebilir.

Gerçek Hayat Örneği:

Dilerseniz bu örneği Dekoratör Tasarım Deseni yazısında söz ettiğimiz e-ticaret uygulaması üzerinden devam ettirelim.

Kısaca hatırlatmak gerekirse sitemizden aynı kategoriden 3 ürün alan müşteriye 2 fiyatı ödetecek ve 10 TL indirim vereecktik. Bu işlemi yaparken dekoratör ve strateji tasarım desenlerinden yararlanmıştık. Şimdi bu örneği biraz daha özelleştirelim.

Kullanıcımızın, yeni yıl kategorisinden satın alacağı 3 adet 100 TL üzeri ürün için 2 fiyatı ödetelim ve 10 TL indirim uygulayalım.

Uygulama:

Örnekde belirttiğimiz şartlara uygun olan sepet ürünlerini filtrelemek için oluşturacağımız filtrelerin implement edeceği arayüz sınıfını oluşturalım.

<?php
namespace Promotion;

interface FilterInterface
{
    /**
     * @param Traversable $items
     * @param array $args
     * @return Generator
     */
    public function apply(Traversable $items, array $args=array());
}

Kullanıcıya sağlayacağımız fırsatın ilk şartı kategori ekseninde olduğuna göre sepet öğelerini kategori bazlı filtreleyecek filtre sınıfını kodlayalım.

<?php

namespace Promotion\Filter;

use Promotion\FilterInterface;

class CategoryFilter implements FilterInterface
{
    /**
     * @param Traversable $items
     * @param array $args
     * @return Generator
     */
    public function apply(Traversable $items, array $args=array())
    {
        foreach($items as $item) {
            if( $item->getCategory()->getId() == $args['category_id'] ) {
                yield $item;
            }
        }
    }
}

Bir sonraki ölçütümüz olan tutar bilgisi için yeni bir filtre sınıfı oluşturalım.

<?php

namespace Promotion\Filter;

use Promotion\FilterInterface;

class PriceFilter implements FilterInterface
{
    const CRITERIA_EQUAL = 'eq';
    const CRITERIA_LESS_THAN = 'lt';
    const CRITERIA_GREATER_THAN = 'gt';
    const CRITERIA_LESS_THAN_OR_EQUAL = 'lte';
    const CRITERIA_GREATER_THAN_OR_EQUAL = 'gte';

    /**
     * @param Traversable $items
     * @param array $args
     * @return Generator
     */
    public function apply(Traversable $items, array $args=array())
    {
        foreach($items as $item) {
            switch($args['condition']) {
                case self::CRITERIA_EQUAL:
                    if($item->getPrice() == $args['price']) {
                        yield $item;
                    }
                    break;
                case self::CRITERIA_LESS_THAN:
                    if($item->getPrice() < $args['price']) {
                        yield $item;
                    }
                    break;
                case self::CRITERIA_GREATER_THAN:
                    if($item->getPrice() > $args['price']) {
                        yield $item;
                    }
                    break;
                case self::CRITERIA_LESS_THAN_OR_EQUAL:
                    if($item->getPrice() <= $args['price']) {
                        yield $item;
                    }
                    break;
                case self::CRITERIA_GREATER_THAN_OR_EQUAL:
                    if($item->getPrice() >= $args['price']) {
                        yield $item;
                    }
                    break;
            }
        }   
    }
}

Son olarak her iki şartı VE lojiğine tabi tutacak filtre sınıfını oluşturalım.

<?php

namespace Promotion\Filter;

use Promotion\FilterInterface;

class AndFilter implements FilterInterface
{
    /**
     * @var FilterInterface $filter1
     */
    private $filter1;

    /**
     * @var FilterInterface $filter2
     */
    private $filter2;

    /**
     * @param FilterInterface $filter1
     * @param FilterInterface $filter2
     */
    public function AndFilter(FilterInterface $filter1, FilterInterface $filter2)
    {
        $this->filter1 = $filter1;
        $this->filter2 = $filter2;
    }

    /**
     * @param Traversable $items
     * @param array $args
     * @return Generator
     */
    public function apply(Traversable $items, array $args=array())
    {
        $filtered = $this->filter1->apply($items, $args);
        return $this->filter2->apply($filtered, $args);
    }
}

Filtrelerimiz hazır olduğuna göre bir önceki örnekde oluşturduğumuz SpecialOfferCalculator sınıfını yeni şartlara göre düzenleyelim.

<?php
namespace Calculator\Calculator;

use Calculator\Calculator\CalculatorAbstract;
use Promotion\Filter\CategoryFilter;
use Promotion\Filter\PriceFilter;
use Promotion\Filter\AndFilter;

class SpecialOfferCalculator extends CalculatorAbstract
{
    const OFFER_LIMIT = 3;
    const OFFER_CATEGORY_ID = 5; // CATEGORY_ID:5 = Yeni Yıl
    const OFFER_PRICE_LIMIT = 100;
    const OFFER_PRICE_COND = PriceFilter::CRITERIA_GREATER_THAN_OR_EQUAL;

    private prepareItems()
    {
        $filter = new AndFilter(new CategoryFilter(), new PriceFilter());
        $filteredItems = $filter->apply(
            $this->decoratedObject->getItems(), 
            array(
                'category_id' => self::OFFER_CATEGORY_ID,
                'price'       => self::OFFER_PRICE_LIMIT,
                'condition'   => self::OFFER_PRICE_COND
            )
        );

        // Generator tip, iterate edilmedigi surece sonuc donmedigi icin,
        // bir sonraki metodda yapilacak belirli kategorideki urun sayisi
        // kontrolu nedeniyle generator tipini diziye donusturuyoruz.
        $items = array();
        foreach($filteredItems as $item) {
            $items[] = $item;
        }
        return $items;
    }

    public function getTotalPrice()
    {
        $totalPrice = $this->decoratedObject->getTotalPrice();
        $items = $this->prepareItems();

        if(count($items) > self::OFFER_LIMIT) {
            // Urunleri pahalidan ucuza siralayarak 100 TL ve uzeri en ucuz
            // urunun tutarini indirim olarak uyguluyoruz.

            usort($items, function($itemA, $itemB) {
                return $itemA->getPrice() > $itemB->getPrice();
            });

            $totalPrice -= end($items)->getPrice();
        }
        return $totalPrice;
    }
}

Artık sepet tutarımızı hesaplamaya hazırız.

<?php
namespace MyApp;

use Basket\Basket;
use Basket\BasketItem;
use Promotion\Discount;
use Calculator\Calculator\TotalPriceCalculator;
use Calculator\Calculator\SpecialOfferCalculator;
use Calculator\Calculator\DiscountCalculator;

class Main
{
    public function main()
    {
        $basket = new Basket();
        $basket->add(new BasketItem("001", new Category(5, 'Yeni Yıl'), 'Gömlek', 150))
            ->add(new BasketItem("001", new Category(5, 'Yeni Yıl'), 'Gömlek', 180))
            ->add(new BasketItem("001", new Category(5, 'Yeni Yıl'), 'Gömlek', 105))
            ->add(new BasketItem("002", new Category(5, 'Yeni Yıl'), 'Pantolon', 80);
        $basket->setDiscount(new Discount(Discount::DISCOUNT_TYPE_FIXED, 10));
        $basket = new DiscountCalculator(
            new SpecialOfferCalculator(
                new TotalPriceCalculator($basket)
            )
        );
        print $basket->getTotalPrice(); 
        // sub total = 150 + 180 + 105 + 80 = 515
        // ofered total = sub total - 105 = 410
        // Payment total = offered total - discount amount (10) = 405 TL
    }
}
Genel Yazılım ve Sistem Mühendisliği

Dekoratör Tasarım Deseni

Dekoratör tasarım deseni, bir nesne üzerinde yapısal değişiklik gerçekleştirmeden yeni yetenekler kazandırılmak istenildiği durumlarda tercih edilen bir tasarım kalıbıdır. Genellikle tekil sorumluluk ilkesi gereği sorumlulukların müferit sınıflar arasında bölünmek istendiği yerlerde tercih edilir. Belirli bir mal veya hizmetin satışında ara toplam, indirimler, vergiler ve özel durumların hesaplanması istendiği durumlar için son derece elverişli bir yapısal tasarım desenidir.

Gerçek Hayat Örneği:

Bir elektronik ticaret sitesinde aşağıdaki kampsamda hizmetler veirlebilmektedir.

* Kullanıcı sepetine istediği kadar ürün ekleyebilir.
* Sabit tutarlı veya yüzdelik cinsten indirimlerden yararlanabilir.

İstisnalar:

* Kullanıcı A kategorisindeki aynı üründen 3 adet satın alırsa 2 tanesinin parasını öder.

Problem:

Kullanıcı yeni yıl kategorisinden 3 adet gömlek satın almış, hesabına tanımlı olan 10 TL lik indirimden yararlanmıştır.

Uygulama:

Başlamadan önce sepet, ürün ve indirim sınıflarımızı tanımlayalım.

namespace Basket;

class BasketItem
{
	/**
	 * @var string
	 */
	private $code;

	/**
	 * @var Category;
	 */
	private $category;

	/**
	 * @var string
	 */
	private $name;

	/**
	 * @var float
	 */
	private $price;

	public function BasketItem($code, $category, $name, $price)
	{
		$this->code = $code;
		$this->cateogry = $categorY;
		$this->name = $name;
		$this->price = $price;
	}

	/**
	 * @return string
	 */
	public function getCode()
	{
		return $this->code;
	}

	/**
	 * @return Category
	 */
	public function getCategory()
	{
		return $this->category;
	}

	/**
	 * @return string
	 */
	public function getName()
	{
		return $this->name;
	}

	/**
	 * @return float
	 */
	public function getPrice()
	{
		return $this->price;
	}
}
<?php
namespace Basket;

use Basket\BasketItem;
use Promotion\Discount;

class Basket
{
	/**
	 * @var SplObjectStorage
	 */
	private $collection;

	/**
	 * @var float
	 */
	private $totalPrice = 0.0;

	/**
	 * @var \Promotion\Discount
	 */
	private $discount;

	public function Basket()
	{
		$this->collection = new SplObjectStorage();
	}

	/**
	 * @return SplObjectStorage
	 */
	public function getItems()
	{
		return $this->collection;
	}

	/**
	 * @param BasketItem $item
	 * @return Basket
	 */
	public function add(BasketItem $item)
	{
		$this->collection->attach($item);
		return $this;
	}
	
	//...

	public function getTotalPrice()
	{
		return $this->totalPrice;
	}

	public function setTotalPrice($value)
	{
		$this->totalPrice = $value;
	}

	/**
	 * @return \Promotion\Discount
	 */
	public function getDiscount()
	{
		return $this->discount;
	}

	/**
	 * @param \Promotion\Discount $discount
	 */
	public function setDiscount(Discount $discount)
	{
		$this->discount = $value;
	}

	//...
}
<?php
namespace Promotion;

class Discount
{
	DISCOUNT_TYPE_FIXED = 'fixed';
	DISCOUNT_TYPE_PERCENTAGE = 'percentage';

	/**
	 * @var string
	 */
	private $type;
	
	/**
	 * @var float
	 */
	private $amount;

	public function Discount($type, $amount)
	{
		$this->type = $type;
		$this->amount = $amount;
	}

	/**
	 * @return string
	 */	
	public function getType()
	{
		return $this->type;
	}

	/**
	 * @return float
	 */
	public function getAmount()
	{
		return $this->amount;
	}
}

Hesaplama işlemi sırasında kullanıcının sepetini dekore edeceğimize göre sepet ve somut dekoratör sınıfları benzer niteliklere sahip olmalıdır. Bunun için sepet ve dekoratör sınıflarının implement edeceği arayüz sınıfını oluşturalım.

<?php
namespace Calculator;

interface Calculatable
{
	public function getTotalPrice();
}

* Sepet nesnesinin yeni oluşturduğumuz arayüzü implement etmesini sağlıyoruz.

<?php
namespace Basket;

use Basket\BasketItem;
use Calculator\Calculatable;

class Basket implements Calculatable
{
	//...
}

Her dekoratör, kurulum sırasında sepeti veya bir başka dekoratörü argüman olarak alabilir. Birden fazla somut dekoratör sınıfım olacağını varsayarak yeni bir soyut dekoratör sınıfı oluşturuyorum.

<?php
namespace Calculator\Calculator;

use Calculator\Calculatable;

abstract class CalculatorAbstract implements Calculatable
{
	/**
	 * @var Calculatable
	 */
	protected $decoratedObject;

	/**
	 * @var Calculatable $decoratedObject
	 */
	public function CalculatorAbstract(Calculatable $decoratedObject)
	{
		$this->decoratedObject = $decoratedObject;
	}

	public function getItems()
	{
		return $this->decoratedObject->getItems();
	}

	public function getTotalPrice()
	{
		return $this->decoratedObject->getTotalPrice();
	}
}

* Sepet toplamını hesaplayacak yeni bir dekoratör sınıfı oluşturuyorum.

<?php
namespace Calculator\Calculator;

use Calculator\Calculator\CalculatorAbstract;

class TotalPriceCalculator extends CalculatorAbstract
{
	public function getTotalPrice()
	{
		$total = 0;
		foreach($this->decoratedObject->getItems() as $item) {
			$total += $item->getPrice();
		}
		return $toal;
	}
}

* Aynı kategorideki bir üründen 3 adet satın alındığında 2 ürün parası ödemeyi sağlayacak decoratörü geliştirelim.

<?php
namespace Calculator\Calculator;

use Calculator\Calculator\CalculatorAbstract;

class SpecialOfferCalculator extends CalculatorAbstract
{
	const OFFER_LIMIT = 3;

	public function getTotalPrice()
	{
		$totalPrice = $this->decoratedObject->getTotalPrice();
		$groupedProducts = array();

		$isDiscountApplied = false;

		foreach($this->decoratedObject->getItems() as $item) {
			$categoryId = $item->getCategory()->getId();
			
			if(!array_key_exists($groupedProducts, $categoryId)) {
				$groupedProducts[$categoryId] = array();
			}
			
			$groupedProducts[$categoryId][] = $item;

			if(count(groupedProducts[$categoryId]) >= self::OFFER_LIMIT and !$isDiscountApplied) {
				$totalPrice -= $item->getPrice();
				$isDiscountApplied = true;
			}
		}

		return $totalPrice;
	}
}

Yazının başında kullanıcıların, indirimleri yüzde veya sabit tutar cinsinden kullanabileceğinden söz etmiştik. Ancak soyut düşündüğümüzde indirim hesaplamak bizim için nihayi rakama ulaşmaktaki adımlardan biri olup, indirimin yüzde veya sabit tutar cinsinden olması ise indirimin hesaplama metodolojisidir. Bu nedenle indirim hesaplama yöntemini sepet hesaplayıcılardan soyutlamak için strateji tasarım desenini kullanarak yeni bir indirim hesaplayıcı sınıf ailesi oluşturacağız.

<?php
namespace Promotion\Discount;

interface DiscountType
{
	/**
	 * @param float $discountAmount
	 * @param float $price
	 */
	public function calculate($discountAmount, $price);
}
<?php
namespace Promotion\Discount;

use Promotion\Discount\DiscountType;

class FixedDiscount implements DiscountType
{
	/**
	 * @param float $discountAmount
	 * @param float $price
	 */
	public function calculate($discountAmount, $price)
	{
		return $price - $discountAmount;
	}
}
<?php
namespace Promotion\Discount;

use Promotion\Discount\DiscountType;

class PercentageDiscount implements DiscountType
{
	/**
	 * @param float $discountAmount
	 * @param float $price
	 */
	public function calculate($discountAmount, $price)
	{
		return $price - ($price * ($discountAmount / 100));
	}
}
<?php
namespace Promotion;

use Promotion\Discount\DiscountType;

class DiscountContext
{
	/**
	 * @var \Promotion\Discount\DiscountType
	 */
	private $discountType;

	public function DiscountContext(DiscountType $discountType)
	{
		$this->discountType = $discountType;
	}

	public function apply($discountAmount, $price)
	{
		return $this->discountType->calculate($discountAmount, $price);
	}
}

* Şimdi de İndirim tutarını sepet toplamına yansıtacak dekoratör sınıfımızı oluşturalım.

namespace Calculator\Calculator;

use Promotion\Discount;
use Promotion\DiscountContext;

class DiscountCalculator extends CalculatorAbstract
{
	public function getTotalPrice()
	{
		$discount = $this->decoratedObject->getDiscount();
		if($discount->getType() == Discount::DISCOUNT_TYPE_FIXED) {
			$discountType = new \Promotion\Discount\FixedDiscount();
		} elseif($discount->getType() == Discount::DISCOUNT_TYPE_PERCENTAGE) {
			$discountType = new \Promotion\Discount\PercentageDiscount();
		} else {
			throw new Exception('Bad discount defination.');
		}
		$context = new DiscountContext($discountType);
		return = $context->apply($discount->getAmount(), $this->decoratedObject->getTotalPrice());
	}
}

Artık sepet tutarımızı hesaplamaya hazırız.

<?php
namespace MyApp;

use Basket\Basket;
use Basket\BasketItem;
use Promotion\Discount;
use Calculator\Calculator\TotalPriceCalculator;
use Calculator\Calculator\SpecialOfferCalculator;
use Calculator\Calculator\DiscountCalculator;

class Main
{
	public function main()
	{
		$basket = new Basket();
		$basket->add(new BasketItem("001", new Category(1, 'Giyim'), 'Gömlek', 80))
			->add(new BasketItem("001", new Category(1, 'Giyim'), 'Gömlek', 80))
			->add(new BasketItem("001", new Category(1, 'Giyim'), 'Gömlek', 80))
			->add(new BasketItem("002", new Category(1, 'Giyim'), 'Pantolon', 200));
		$basket->setDiscount(new Discount(Discount::DISCOUNT_TYPE_FIXED, 10));
		$basket = new DiscountCalculator(new SpecialOfferCalculator(new TotalPriceCalculator($basket)));
		print $basket->getTotalPrice(); //TotalPrice = 350 TL
	}
}

Genel

Django Framework Üzerinde Sinyal Kullanımı

Django, sinyaller vasıtasıyla uygulama genelinde meydana gelen herhangibir olayı, sinyali dinleyen alıcılara bildirir. Geliştiriciler, djanog ile birlikte gelen hali hazırdaki sinyalleri kullanabildikleri gibi (Bkz. Django ile birlikte gelen hali hazırda sinyaller) kendileri de geliştirdikleri uygulamaya özel sinyaller tanımlayabilirler.

Django uygulamalarında sinyaller, alıcılar vasıtasıyla dinlenir. Django dünyasında alıcılar, bilindik python fonksiyonlarıdır.

Farzı misal bakınız bir sinyal alıcısı:

from django.core.signals import request_finished
from django.dispatch import receiver

@receiver(request_finished)
def my_callback(sender, **kwargs):
    print("Request finished!")

Alıcıları, @receiver dekoratörü ile sinyallere bağlayabildiğiniz gibi

request_finished.connect(my_callback)

şeklinde de bağlayabilirsiniz.

Kullanıcı Tanımlı Sinyaller:

Django, bizlere http isteklerinin durumu ve veritabanı işlemleri ile ilgili dahili sinyaller sağlıyor. Ancak bazı durumlarda geliştirdiğiniz uygulamaya spesifik bazı özel sinyaller tanımlamanız gerekebilmektedir. Böyle durumlarda sizler de Django nun django.dispath modülünde yeralan Signal sınıfını kullanabilirsiniz.

Sinyal tanımlamalarını ilgili uygulamanın altında signals.py dosyası içinde gerçekleştirilir.

Aşağıdaki örnekte, e-ticaret uygulamamızın sipariş tamamlandığında order_completed sinyalini tetiklemesini sağlıyoruz.

öncelikle order_completed sinyalini tanımlayalım:

# order/signals.py

import django.dispath

order_completed = django.dispath.Signal(providing_args=['order'])

Şimdi de sipariş tamamlandığında bu olayı tetikleyelim.

# order/services.py

from order.signals import order_completed

class OrderManager(object):
    def create_order(self, *args, **kwargs):
        # siparisle ilgili islemler...
        #
        # yeni siparis yaratiliyor.
        order = Order.objects.create(order_nr='00001234')

        # ...ve siparis tamamlandi olayini tetikliyoruz.
        order_completed.send(sender=self, order=order)
        return order

Herhangibir sipariş geldiğinde, sipariş order tablosuna yazıldıktan hemen sonra order_completed sinyalinin gönderildiğini görebiliyoruz. Artık diledğimiz bir veya daha fazla alıcı ile bu sinyali dinleyerek bu sinyalle ilgili herhangibir işlemi gerçekleştirebiliriz. Yeri gelmişken Django uygulamalarında sinyallerin senkron çalıştığını söylemekte yarar var. Alıcı tarafında meydana gelen herhangibir darboğaz veya hata, uygulamanın yavaşlamasına veya kırılmasına neden olabilir.

Şimdi de aynı örnek için order_completed olayını dinleyen bir alıcı kodlayalım. Alıcılar konusunda malesef standart bir yaklaşım yok. İnternette görebileceğiniz örneklerde alıcılar şayet modelle ilgili bir alıcıysa ilgili olduğu uygulamının models.py dosyasına sinyal konusu olan model sınıfının hemen altına yazılıyor.

Şahsi görüşüm, sinyal alıcılarının business logic içermesi ve modelle ilgisinin sadece kendisiyle olan bağ olması nedeniyle ayrı bir yerde tutulması gerektiği yönünde. Bu nedenle ben, yeraldığım projelerde sinyal alıcılarını ilgili uygulamanın altında receivers.py içinde barındırmayı tercih ediyorum. Tabi bu durumda alıcıların uygulama genelinde işlevlerini yerine getirebilmeleri için merkezi biryerlerde import edilmeleri gerektiğinden import işlemini urls.py içerisinde gerçekleştiriyorum.

Aşağıdaki örnek alıcı, sipariş tamamlandığında yöneticiye sipariş tamamlandı maili gönderir.

# order/receivers.py

from django.dispatch import receiver
from django.core.mail import mail_admins
from order.signals import order_completed

@receiver(order_completed, 
          dispatch_uid="order.receivers.send_order_notification")
def send_order_notification(sender, order, **kwargs):
    mail_admins(subject='order completed #%s' % order.order_nr,
                message='Received a new order from site. '
                'New order number is: #%s' % order.order_nr)

Alıcının işlevini yerine getirebilmesi için urls.py dosyasında recivers.py ın içerdiği alıcıları import ediyoruz.

# urls.py

from order.receivers import *

# ...

Detaylı bilgi için Django Framework dökümantasyonundaki ilgili bölümü inceleyebilirsiniz.

Programa Dilleri ve Çatıları

Hadise var dediler, geldik!

HadiseHadise, çok ilkel (basit) bir olay güdümlü programlama kütüphanesidir. Mevcut PHP aplikasyonunuza basitce implemente ederek yazılımınızın akışını tetiklediğiniz olaylar doğrultusunda yönetebilirsiniz.

Hadise kütüphanesinin en güncel sürümünü aşağıdaki github reposunda bulabilirsiniz:
https://github.com/ibrahimgunduz34/hadise

Örneğin projenizin içindeki basit bir api implementasyonuna hadise kütüphanesini uyarlayalım.

Öncelikle olay dinleyecilerimizi kodlayalım.
İlk olarak istek göndermeden önce tetikleyeceğimiz olay dinleyicimizi ile başlayalım.

use \Hadise\IEventListener;
use \Hadise\Event;
class BeforeRequestListener implements IEventListener
{
  public function invoke(Event $event)
  {
    $logData = sprintf("Source:\n" .
                       "------------------\n" .
                       "%s\n" .
                       "Request:\n" .
                       "------------\n" .
                       "%s\n", get_class($event->getSource()),
                       var_export($event->getParameters(), true);
    file_put_contents('transaction_log', $logData, FILE_APPEND);
  }
}

Şimdi de istek gönderdikten sonra tetikleyeceğimiz olay dinleyicimizi kodlayalım.

use \Hadise\IEventListener;
use \Hadise\Event;
class AfterRequestListener implements IEventListener
{
  public function invoke(Event $event)
  {
    $logData = sprintf("Source:\n" .
                       "------------------\n" .
                       "%s\n" .
                       "Response:\n" .
                       "------------\n" .
                       "%s\n", get_class($event->getSource()),
                       var_export($event->getParameters(), true);
    file_put_contents('transaction_log', $logData, FILE_APPEND);
  }
}

Mevcut api implementasyonumuzda istek öncesi ve sonrasında olay dinleyicilerimizin tetiklenmesini sağlayalım.

class MyApiImpl implements MyApiImplInterface
{
  //...
  protected function __sendRequest($url, array $data)
  {
    $requestXML = http_build_query($data);
    EventManager::getManager('MyApiImpl')->riseEvent('beforeRequest', $this, array('data' => $requestXML));
        
    $ch = curl_init();
    //...
    $responseData = curl_exec($ch);
    //...
    EventManager::getManager('MyApiImpl')->riseEvent('afterRequest', $this, array('data' => $responseData));
  }
  //...
}

Son olarak olay dinleyicilerimizi olay yöneticimize iliştirelim.

EventManager::getManager('MyApiImpl')
            ->addListener('beforeRequest', new BeforeRequestListener());
EventManager::getManager('MyApiImpl')
            ->addListener('afterRequest', new AfterRequestListener());

Hepsi bu kadar. İyi eğlenceler :)

Yazılım ve Sistem Mühendisliği

Bi Fonksiyon Yazdım…

Bugün de yazılım dünyasının kanayan başka bir yarasına deyinelim dedim. :)

Kod tekrarının sıkca yapıldığı umumiyetle de OOP olmayan projelerde aynı işi farklı parametrelerle gerçekleştirip benzer çıktılar üreten fonksiyonlar görmeniz olasıdır. Genellikle bu tarz durumlarda tepesi atan bir geliştirici refactoring yapma aşkıyla sistemdeki benzer tüm fonksiyonları birleştirip leb demeden çerez tabağı üreten fonksiyonlar geliştirir.:) Bu yaklaşımın ne kadar yanlış olduğunu anlamak için öncelikle şu yazıyı incelemenizi öneririm.

Bugün de yine birlikte gerçek hayattan bir örnek inceleyeceğiz. Elektronik ticaret şirketleri, oto servisleri veya perakende ürün/hizmet satışı yapılan yerlerde müşteriye satılan bir ürün ve bu ürünün satışı ile ilgili değişik iş modelleri vardır. Partenere göre, satış kurallarına göre, kullanılan kupona göre indirim, vergi ve ürün fiyatı değişkenlik gösterebilir ve siz bu problemi “Bir tane fonksiyon yazdım…” yaklaşaımıyla çözemezsiniz. Peki bu problemin ilacı ne ola ?

Örnek olarak inceleyeceğimiz yapıda bir elektronik ticaret sitesinin sepet hesaplamasını konu alacağız. Satış modelimiz yüzdelikli ve sabit tutarlı kupon kullanımından ibaret olacak.

Sepet hesaaplaması yaparken sırasıyla aşağıdaki işlemleri yapmamız gerekiyor.

  • Kupon tipine göre indirim tutarını hesaplamak.
  • Ürün ve sepet bazında KDV tutarı hesaplamak.
  • Sepet toplamını hesaplamak.

Strategy design pattern İlk maddeyi ele alacak olursak kullanacağımız kuponun tipine bağlı olarak indirim tutarını farklı algoritmalarla hesaplamamız gerektiğinden burada kullanabileceğimiz en doğru tasarım kalıbı strateji tasarım desenidir. Strateji tasarım deseni, belirli bir işlemin farklı algoritmalarla gerçekleştirilmesi gerektiği durumlarda kullanılan oluşumsal bir tasarım desenidir. Daha fazla bilgi için bu yazıyı inceleyebilirsiniz.

Decorator Design Pattern Örneği genel olarak ele aldığımızda ise indirim, kdv ve sepet toplamı gibi hesaplamaların ayrı ayrı yapılarak siparişi güncellemesi gerektiğini görüyoruz. Bu durumda kullanabileceğimiz en doğru tasarım deseni ise dekoratör tasarım desenidir. Dekoratör tasarım deseni, bir nesnenin özelliklerinin dinamik olarak değiştirilmesi gerektiği durumlarda kullanılır. Daha fazla bilgi için bu yazıyı inceleyebilrsiniz.

Kodlama kısmı yazıyı biraz uzattığı için sizleri sıkmamak adına bu yazıda yalnızca kupon hesaplayıcıyı inceliyor olacağız.

Öncelikle sipariş ve siparişe bağlı ürün sınıflarımızı oluşturalım.

<?php 
class Order
{
	/**
	 * @var string
	 */
	public $orderNumber;
	
	/**
	 * @var float
	 */
	public $netTotal;
	
	/**
	 * @var float
	 */
	public $totalDiscount;
	
	/**
	 * @var float
	 */
	public $totalTax;
	
	/**
	 * @var float
	 */
	public $grandTotal;

	/**
	 * @var array
	 */
	public $items = array();
       
        /**
         * @string
         */
        public $couponCode;

        /**
         * @int
         */
        public $couponType;
}

class Product
{
	/**
	 * @var string
	 */
	public $sku;
	
	/**
	 * @var float
	 */
	public $netPrice;
	
	/**
	 * @var float
	 */
	public $discountPercent;
	
	/**
	 * @var float
	 */
	public $discountAmount;
	
	/**
	 * @var float
	 */
	public $taxPercent;
	
	/**
	 * @var float
	 */
	public $taxAmount;
	
	/**
	 * @var float
	 */
	public $lineTotal;
}

Kupon hesaplayıcılarımız aynı işi farklı algoritmalarla gerçekleştiren iki farklı sınıf olacağına göre belirli bir arayüze tabi olmaları gerekir.

interface ICouponCalculator
{
	const CALCULATOR_FIXED = 1;
	const CALCULATOR_PERCENT = 2;
	
	/**
	 * @param Product $product
	 * @return float
	 */
	public function calculate(Product $product);
}

İndirim miktarı sepete dağıtılacağından indirim miktarı (oran veya sabit tutar olarak) ve toplam tutar verilerini hesaplayıcı örneğini oluştururken daha sonra kullanmak üzere saklıyoruz. Bu işlemi soyut hesaplayıcı sınıfımızın __construct() metodu içerisinde gerçekleştireceğiz.

abstract class AbstractCouponCalculator
{
	/**
	 * @var float
	 */
	protected $_discount_amount;
	
	/**
	 * @var float
	 */
	protected $_total_amount;
	
	/**
	 * @var float
	 */
	protected $_rounding_errors;
	
	/**
	 * @param float $discountAmount
	 * @param float $totalAmount
	 */
	public function __construct($discountAmount, $totalAmount)
	{
		$this->_discount_amount = $discountAmount;
		$this->_total_amount = $totalAmount;
	}
}

Ön hazırlıklarımızı tamamladığımıza göre hesaplayıcılarımızı kodlamaya başlayabiliriz. İlk olarak sabit tutarlı hesaplayıcımızı kodlayarak başlayalım.

class FixedCouponCalculator extends AbstractCouponCalculator implements ICouponCalculator
{
	/**
	 * (non-PHPdoc)
	 * @see ICouponCalculator::calculate()
	 */
	public function calculate(Product $product)
	{
		$percentage = $product->netPrice / $this->_total_amount;
		$discountAmount = $this->_rounding_errors + ($this->_discount_amount * $percentage);
                //yuvarlamadan kaynaklanan hatalari ihmal etmiyoruz.
		$this->_rounding_errors = $discountAmount - round($discountAmount);
                return $discountAmount;
	}	
}

Şimdi de oransal kupon hesaplayıcımızı kodlayalım.

class PercentCouponCalculator extends AbstractCouponCalculator implements ICouponCalculator
{
	/**
	 * (non-PHPdoc)
	 * @see ICouponCalculator::calculate()
	 */
	public function calculate(Product $product)
	{
		$discountAmount = $product->netPrice * $this->_discount_amount;
		return $discountAmount;
	}
}

Geldik hesaplama stratejimizi belirlemeye. Şimdi de kupon tipine göre hesaplama yapacak strateji sınıfımızı kodlayalım.

class CouponCalculator implements ICouponCalculator
{
	/**
	 * @var ICouponCalculator
	 */
	private $_calculator;
	
	/**
	 * @param int $calculatorType
	 * @param float $discountAmount
	 * @param float $totalAmount
	 */
	public function __construct($calculatorType, $discountAmount, $totalAmount)
	{
		switch($calculatorType) {
			case ICouponCalculator::CALCULATOR_FIXED:
				$this->_calculator = new FixedCouponCalculator($discountAmount, $totalAmount);
				break;
			case ICouponCalculator::CALCULATOR_PERCENT:
				$this->_calculator = new PercentCouponCalculator($discountAmount, $totalAmount);
				break;
		}
	}
	
	/**
	 * (non-PHPdoc)
	 * @see ICouponCalculator::calculate()
	 */
	public function calculate(Product $product)
	{
		return $this->_calculator->calculate($product);
	}
} 

Bir sonraki yazıda dekoratör tasarım desenini kullanarak sizlerle birlikte sepet hesaplayıcısını kodlayacağız.

Yazılım ve Sistem Mühendisliği

Observer Tasarım Kalıbı ve Olay Güdümlü Programlama

Üzerinde çalıştığım bir projeye kısa bir çay molası vermişken sizlerle çok sevdiğim ve şu an üzerinde çalıştığım projede de kullandığım gözlemci (observer) tasarım kalıbı ve olay güdümlü programlama konularndan kısaca bahsetmek istiyorum.

87628254
Olay güdümlü programlama, iç veya dış etkenlerle meydana gelen olaylar doğrultusunda program akışının değiştirilmesi gerektiği durumlarda kullanılan bir tekniktir. Bir e-ticaret sitesinde ziyaretcinin herhangibir nedenle alışverişi tamamlayamaması durumunda belirli bir kullanıcı gurubunun haberdar edilmesi, herhangibir servisle iletişim sorunu olması durumunda aksiyon alınması gibi durumlar, olay güdümlü programlama gerektirir.

Observer
Observer tasarım kalıbı ise birbirleriyle bire-çok ilişki içindeki nesnelerden herhangibirinde değişiklik olması durumunda bir merkez üzerinden diğer nesnelerin haberdar edilmesi gerektiği durumlarda kullanılır ve olay güdümlü programlama için biçilmiş kaftandır :)

Dilerseniz gelin hemen birlikte gerçek hayattan bir örnek inceleylim.

Bir elektronik ticaret şirketinde çalışıyoruz. Saat başı zamanlanmış bir görevle gelen siparişleri lojistik şirketine iletiyoruz. Ancak siparişlerin herhangibir nedenle iletilememesi durumunda 1 dk bekleyip tekrar deneme gerçekleştirmek istiyoruz.

Kod örneğine geçmeden önce gözlemci tasarım kalıbı ve olay güdümlü programlama arasındaki ilişki konusunda kısa bir bilgi vermekte yarar var. Observer tasarım desenini kullanarak yazılımımızın akışıını olaylarla değiştirebilmek için olayın gerçekleştiği yeri merkez, olayı dinleyen bölümü observer olarak düşünmeliyiz.

Aşağıdaki gibi bir lojistik arayüzümüz var. Tüm lojistik implementasyonlarımız bu arayüzü implement eder.

interface ILogistic
{
	/**
	 * @param string $articleCode
	 * @param string $refNumber
	 * @return bool
	 */
	public function send($articleCode, $refNumber);
	
	/**
	 * @param string $refNum
	 * @return string
	 */
	public function getStatus($refNum);
}

Basit ve anlaşılır olması açısından herbir gözlemcinin tek bir olay içerdiğini varsayıyoruz. Aşağıda gözlemci sınıflarımızın implement edeceği arayüz kodu yeralıyor.

interface IObserver
{
	/**
	 * @param Event $event
	 */
	public function invoke(Event $event);
}

Olayın gerçekleşeceği bölümün implement edeceği IObservable arayüzünü kodlayalım.

interface IObservable
{
	/**
	 * @param IObserver $observer
	 * @param string $eventName
	 */
	public function attach(IObserver $observer, $eventName);
	
	/**
	 * @param Event $event
	 */
	public function fireEvent(Event $event);
}

Olay gerçekleştiğinde olayla ilgili bilgileri gözlemciye (observer) taşıyacak olay sınıfımızı kodlayalım.

class Event
{
	/**
	 * @var string
	 */
	private $_event_type;
	
	/**
	 * @var IObservable
	 */
	private $_source;
	
	/**
	 * @var string
	 */
	private $_last_called_method;
	
	/**
	 * @var array
	 */
	private $_arguments;
	
	/**
	 * @param string $eventName
	 * @param IObservable $source
	 * @param string $lastCalledMethod
	 * @param array $arguments
	 */
	public function __construct($eventName,  IObservable $source, $lastCalledMethod, array $arguments)
	{
		$this->_event_name = $eventName;
		$this->_source = $source;
		$this->_last_called_method = $lastCalledMethod;
		$this->_arguments = $arguments;
	}
	
	/**
	 * @return string
	 */
	public function getEventName()
	{
		return $this->_event_type;
	}
	
	/**
	 * @return IObservable
	 */
	public function getSource()
	{
		return $this->_source;
	}
	
	/**
	 * @return string
	 */
	public function getLastCalledMethod()
	{
		return $this->_last_called_method;
	}
	
	/**
	 * @return array
	 */
	public function getArguments()
	{
		return $this->_arguments;
	}
}

Lojistik implementasyonlarımızın devralacağı soyut sınıfımızı kodlayalım.

abstract class LogisticAbstract
{	
	/**
	 * @param string $articleCode
	 * @param string $refNum
	 * @return array
	 */
	abstract protected function _getSendRequest($articleCode, $refNum);
	
	/**
	 * @param string $refNum
	 * @return array
	 */
	abstract protected function _getStatusRequest($refNum);
	
	/**
	 * @param string $apiResponse
	 * @return bool
	 */
	abstract protected function _parseSendRequest($apiResponse);
	
	/**
	 * @param string $apiResponse
	 * @return string
	 */
	abstract protected function _parseStatusRequest($apiResponse);
	
	/**
	 * @param string $url
	 * @param array $data
	 * @throws Exception
	 * @return string
	 */
	protected function _sendRequest($url, array $data)
	{
		$postData = http_build_query($data);
		$ch = curl_init();
		$options = array(CURLOPT_URL => $url,
					    CURLOPT_RETURNTRANSFER => true,
					    CURLOPT_POST 	   => true,
					    CURLOPT_POSTFIELDS 	   => $postData);
		curl_setopt_array($ch, $options);
		$response = curl_exec($ch);
	    if($error = curl_errno($ch)) {
	    	throw new Exception('Error occurred while sending data to remote server. Detail:' . $error, '');
	    }
	    return $response;
	}
}

Lojistik şirketimizin adı örnek lojistik olsun.

class OrnekLojistik extends LogisticAbstract implements ILogistic, IObservable
{
	/**
	 * @var array
	 */
	private $_observers = array();
	
	/**
	 * @param string $articleCode
	 * @param string $refNumber
	 * @return array
	 */
	protected function _getSendRequest($articleCode, $refNumber)
	{
		$xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>
				<OrnekLogisticRequest>
				  <transaction>
				  <type>send</type>
				  <articleCode>{$articleCode}</articleCode>
				  <refNum>{$refNumber}</refNum>
				  </transaction>
				</OrnekLogisticRequest>";
		return array('data' => $xml);
	}
	
	/**
	 * @param string $refNum
	 * @return array
	 */
	protected function _getStatusRequest($refNum)
	{
		//...
	}
	
	/**
	 * @param string $apiResponse
	 */
	protected function _parseSendRequest($apiResponse)
	{
		try {
			$xml = new SimpleXMLElement($xml);
			return $xml->Response->Status == 'OK';		
		} catch(Exception $e) {
			throw new Exception('Unexpected Response. Response message:' . $apiResponse);
		}
	}
	
	/**
	 * @param string $apiResponse
	*/
	protected function _parseStatusRequest($apiResponse)
	{
		//...
	}
	
	/**
	 * @param string $articleCode
	 * @param string $refNumber
	 */
	public function send($articleCode, $refNumber)
	{
		try {
			$request = $this->_getSendRequest($articleCode, $refNumber);
			$apiResponse = $this->_sendRequest('http://ws.orneklojistik.com/OrnekWS.php', $request);
			$response = $this->_parseSendRequest($apiResponse);
			if(! $response ) {
				$this->fireEvent(new Event('shipping_failed', $this, __METHOD__, func_get_args() ));
			}
			return $response;
		} catch(Exception $e) {
			$this->fireEvent(new Event('shipping_failed', $this, __METHOD__, func_get_args() ));
                        return false;
		}
	}
	
	/**
	 * @param string $refNum
	*/
	public function getStatus($refNum)
	{
		//...		
	}
	
	/**
	 * (non-PHPdoc)
	 * @see IObservable::attach()
	 */
	public function attach(IObserver $observer, $eventName)
	{
		if( ! isset( $this->_observers[$eventName] ) ) {
			$this->_observers[$eventName] = array();
		}
		$this->_observers[$eventName][] = $observer;
	}
	
	/**
	 * (non-PHPdoc)
	 * @see IObservable::fireEvent()
	 */
	public function fireEvent(Event $event)
	{
		if( isset( $this->_observers[$event->getEventName() ] ) ) {
			/* @var $event IObserver  */
			foreach ($this->_observers[$event->getEventName()] as $observer) {
				$observer->invoke($event);
			}
		}
	}
}

Lojistik şirketine gönderim sırasında sorun yaşamamız durumunda çalışacak gözlemci sınıfını kodlayalım.

class OrnekLojistik_Observer_OnFail implements IObserver
{
	/**
	 * @var bool
	 */
	private $_tried = false;

	/**
	 * (non-PHPdoc)
	 * @see IObserver::invoke()
	 */
	public function invoke(Event $event)
	{
		if( ! $this->_tried ) {
			sleep(60);
			call_user_method($event->getLastCalledMethod(), $event->getSource(), $event->getArguments());
		}	
	}
}

Geldik zamanlanmış görevimize. Buyrun size zamanlanmış görev…

class SendLogisticCommand implements ICommand
{
	/**
	 * @param array $args
	 */
	public function run($args)
	{
		$products = array('ABC123', 'DEF234', 'GHI123');
		
		$logistic = new OrnekLojistik();
		$observer = new OrnekLojistik_Observer_OnFail();
		$logistic->attach($observer, 'shipping_failed');
		
		foreach($products as $product) {
			$logistic->send($product, time() );
		}
	}
}

Biraz uzun oldu sanırım :) Hızlıca hazırladığım için ufak tefek hiyerarşi sıkıntıları olabilir ancak genel anlamda sizlere fikir verebileceğini ümit ediyorum.