Ba─č─▒ml─▒l─▒k enjeksiyonu nedir?


Al─▒nan cevaba git


Ba─č─▒ml─▒l─▒k enjeksiyonuyla ilgili , ne zaman kullan─▒laca─č─▒ ve bunun i├žin hangi ├žer├ževelerin oldu─ču gibi, belirli sorularla ilgili bir├žok soru yay─▒nlanm─▒┼čt─▒r . Ancak,

Ba─č─▒ml─▒l─▒k enjeksiyonu nedir ve ne zaman / neden kullan─▒lmal─▒ veya kullan─▒lmamal─▒d─▒r?


2962





2008-09-25




Cevap say─▒s─▒n─▒ say: 30






Ba─č─▒ml─▒l─▒k Enjeksiyonu di─čer nesnelere veya ├žer├ževeye ba─č─▒ml─▒l─▒k ge├žiriyor (ba─č─▒ml─▒l─▒k enjekt├Âr├╝).

Ba─č─▒ml─▒l─▒k enjeksiyonu testi kolayla┼čt─▒r─▒r. Enjeksiyon yap─▒c─▒dan yap─▒labilir .

SomeClass() a┼ča─č─▒daki ┼čekilde yap─▒c─▒s─▒na sahiptir:

 public SomeClass() {
    myObject = Factory.getObject();
}
 

Sorun : myObject Disk eri┼čimi veya a─č eri┼čimi gibi karma┼č─▒k g├Ârevler i├žeriyorsa, birim testini yapmak zordur SomeClass() . Programc─▒lar alay etmek zorundad─▒r myObject ve fabrika ├ža─čr─▒s─▒na m├╝dahale edebilir.

Alternatif ├ž├Âz├╝m :

  • Yap─▒c─▒ya myObject bir arg├╝man olarak ge├žmek
 public SomeClass (MyClass myObject) {
    this.myObject = myObject;
}
 

myObject testi kolayla┼čt─▒ran do─črudan ge├žilebilir.

  • Ortak bir alternatif, hi├žbir i┼če yaramaz yap─▒c─▒ tan─▒mlamakt─▒r . Ba─č─▒ml─▒l─▒k enjeksiyonu ayarlay─▒c─▒larla yap─▒labilir. (h / t @ MikeVella).
  • Martin Fowler , s─▒n─▒flay─▒c─▒lar─▒n programc─▒lar─▒n enjekte edilmek istedikleri ba─č─▒ml─▒l─▒klar i├žin a├ž─▒k├ža bir aray├╝z uygulad─▒klar─▒ ├╝├ž├╝nc├╝ bir alternatifi (h / t @MarcDix) belgeler .

Ba─č─▒ml─▒l─▒k enjeksiyonuna gerek kalmadan ├╝nite testlerinde bile┼čenleri izole etmek daha zordur.

2013'te bu cevab─▒ yazd─▒─č─▒mda, bu Google Test Blogunda b├╝y├╝k bir temayd─▒ . Programc─▒lar, ├žal─▒┼čma zaman─▒ tasar─▒mlar─▒nda her zaman ekstra esnekli─če ihtiya├ž duymad─▒klar─▒ndan (├Ârne─čin, servis bulucu veya benzeri modeller i├žin), bu benim i├žin en b├╝y├╝k avantajd─▒r. Programc─▒lar test s─▒ras─▒nda genellikle s─▒n─▒flar─▒ izole etmelidir.


1864


2008-09-25





┼×imdiye kadar buldu─čum en iyi tan─▒m , James Shore taraf─▒ndan tan─▒mlanm─▒┼čt─▒r :

"Ba─č─▒ml─▒l─▒k Enjeksiyonu", 5 kuru┼č konsepti i├žin 25 dolarl─▒k bir terimdir. [...] Ba─č─▒ml─▒l─▒k enjeksiyonu, nesneye ├Ârnek de─či┼čkenlerini vermek anlam─▒na gelir. [...].

Martin Fowler taraf─▒ndan da faydal─▒ olabilecek bir makale var .

Ba─č─▒ml─▒l─▒k enjeksiyonu temel olarak bir nesnenin kendisi yapmas─▒ yerine ihtiya├ž duydu─ču nesneleri (ba─č─▒ml─▒l─▒klar─▒n─▒) sa─čl─▒yor. Ba─č─▒ml─▒l─▒klar─▒n alay edilmesine veya engellenmesine izin verdi─či i├žin test i├žin ├žok faydal─▒ bir tekniktir.

Ba─č─▒ml─▒l─▒klar nesnelere bir├žok yolla enjekte edilebilir (yap─▒c─▒ enjeksiyon veya ayarlay─▒c─▒ enjeksiyon gibi). Biri bunu yapmak i├žin ├Âzel ba─č─▒ml─▒l─▒k enjeksiyon ├žer├ževelerini (├Ârne─čin Bahar) kullanabilir, ancak kesinlikle gerekli de─čildir. Ba─č─▒ml─▒l─▒k enjeksiyonuna sahip olmak i├žin bu ├žer├ževelere ihtiyac─▒n─▒z yok. Nesnelerin (ba─č─▒ml─▒l─▒klar─▒n) a├ž─▒k├ža ifade edilmesi ve aktar─▒lmas─▒, ├žer├ževe taraf─▒ndan enjeksiyon yapmak kadar bir enjeksiyon kadar iyidir.


2279







Bu komik ├Ârne─či gev┼ček kavrama a├ž─▒s─▒ndan buldum :

Herhangi bir uygulama, faydal─▒ ┼čeyler yapmak i├žin birbirleriyle i┼čbirli─či yapan pek ├žok nesneden olu┼čur. Geleneksel olarak her nesne, birlikte ├žal─▒┼čt─▒─č─▒ ba─č─▒ml─▒ nesnelere (ba─č─▒ml─▒l─▒klar) kendi referanslar─▒n─▒ almaktan sorumludur. Bu, y├╝ksek derecede e┼čle┼čmi┼č s─▒n─▒flara ve test edilmesi zor bir koda yol a├žar.

├ľrne─čin, bir Car nesneyi d├╝┼č├╝n├╝n .

A Car , tekerleklerin, motorun, yak─▒t─▒n, ak├╝n├╝n vb. ├çal─▒┼čmas─▒na ba─čl─▒d─▒r. Geleneksel olarak, bu t├╝r ba─č─▒ml─▒ nesnelerin markas─▒n─▒, Car nesnenin tan─▒m─▒ ile birlikte tan─▒mlar─▒z .

Ba─č─▒ml─▒l─▒k Enjeksiyonu olmadan (DI):

 class Car{
  private Wheel wh = new NepaliRubberWheel();
  private Battery bt = new ExcideBattery();

  //The rest
}
 

Burada, Car nesne ba─č─▒ml─▒ nesneleri olu┼čturmaktan sorumludur.

Wheel ─░lk NepaliRubberWheel() delinmelerden sonra ba─č─▒ml─▒ nesnesinin t├╝r├╝n├╝ (├Ârne─čin, s├Âyle) de─či┼čtirmek istiyorsak ne olur ? Car nesnesini yeni ba─č─▒ml─▒l─▒─č─▒ ile yeniden yaratmam─▒z gerekiyor ChineseRubberWheel() , ancak bunu yaln─▒zca Car ├╝retici yapabilir.

O zaman Dependency Injection bizim i├žin ne yapar ?

Ba─č─▒ml─▒l─▒k enjeksiyonunu kullan─▒rken nesnelere, derleme zaman─▒ (ara├ž ├╝retim zaman─▒) yerine ├žal─▒┼čma zaman─▒nda ba─č─▒ml─▒l─▒klar─▒ verilir . B├Âylece ┼čimdi Wheel istedi─čimiz zaman de─či┼čtirebiliriz . Burada, dependency ( wheel ) Car ├žal─▒┼čma zaman─▒nda enjekte edilebilir .

Ba─č─▒ml─▒l─▒k enjeksiyonunu kulland─▒ktan sonra:

Burada, vard─▒r enjekte ba─č─▒ml─▒l─▒klar─▒ zaman─▒nda (Tekerlek ve Pil). Dolay─▒s─▒yla terim: Ba─č─▒ml─▒l─▒k Enjeksiyonu.

 class Car{
  private Wheel wh; // Inject an Instance of Wheel (dependency of car) at runtime
  private Battery bt; // Inject an Instance of Battery (dependency of car) at runtime
  Car(Wheel wh,Battery bt) {
      this.wh = wh;
      this.bt = bt;
  }
  //Or we can have setters
  void setWheel(Wheel wh) {
      this.wh = wh;
  }
}
 

Kaynak: Ba─č─▒ml─▒l─▒k enjeksiyonunu anlama


613







Ba─č─▒ml─▒l─▒k Enjeksiyonu, nesnelerin dahili olarak in┼ča etmek yerine nesnelerin ├Ârneklerini di─čer kod par├žalar─▒ndan alacaklar─▒ ┼čekilde tasarland─▒─č─▒ bir uygulamad─▒r. Bu, nesne taraf─▒ndan istenen aray├╝z├╝ uygulayan herhangi bir nesnenin, kodu de─či┼čtirmeden de─či┼čtirilebilece─či anlam─▒na gelir; bu, testi basitle┼čtirir ve ayr─▒┼čt─▒rmay─▒ geli┼čtirir.

├ľrne─čin, ┼ču ipleri g├Âz ├Ân├╝nde bulundurun:

 public class PersonService {
  public void addManager( Person employee, Person newManager ) { ... }
  public void removeManager( Person employee, Person oldManager ) { ... }
  public Group getGroupByManager( Person manager ) { ... }
}

public class GroupMembershipService() {
  public void addPersonToGroup( Person person, Group group ) { ... }
  public void removePersonFromGroup( Person person, Group group ) { ... }
} 
 

Bu ├Ârnekte, ├žal─▒┼čmas─▒n─▒ yapabilmek i├žin bir ├Ârne─činin uygulanmas─▒ PersonService::addManager ve PersonService::removeManager gerekmesi gerekecektir GroupMembershipService . Ba─č─▒ml─▒l─▒k Enjeksiyon olmadan, bunu yapman─▒n geleneksel yolu yeni bir ├Ârne─čini olacakt─▒r GroupMembershipService kurucular─▒ i├žindedir PersonService ve her iki i┼člevlerde bu ├Ârnek ├Âzniteli─čini kullan─▒n. Bununla birlikte, e─čer GroupMembershipService yap─▒c─▒n─▒n ihtiya├ž duydu─ču birden fazla ┼čeye sahipse veya daha da k├Ât├╝s├╝, ├╝zerinde ├ža─čr─▒lmas─▒ gereken baz─▒ ba┼člatma "ayarlay─▒c─▒lar─▒" varsa GroupMembershipService , kod olduk├ža h─▒zl─▒ bir ┼čekilde b├╝y├╝r ve PersonService ┼čimdi sadece sadece de─čil, GroupMembershipService ayn─▒ zamanda di─čer her ┼čeye de ba─čl─▒d─▒r . GroupMembershipService ba─čl─▒d─▒r. Ayr─▒ca, ba─člant─▒ GroupMembershipService , i├žine kodlanm─▒┼č olarak kodlanm─▒┼čt─▒r; PersonService bu da, GroupMembershipService test amac─▒yla veya " uygulaman─▒z─▒n farkl─▒ b├Âl├╝mlerinde bir strateji deseni kullanamayaca─č─▒n─▒z " anlam─▒na gelemeyece─činiz anlam─▒na gelir .

Ba─č─▒ml─▒l─▒k Enjeksiyonu ile, i├žinizin GroupMembershipService i├žindekileri ba┼člatmak yerine PersonService , onu yap─▒c─▒ya iletirsiniz ya da PersonService yerel bir ├Ârne─čini belirlemek i├žin bir ├ľzellik (al─▒c─▒ ve ayarlay─▒c─▒) eklersiniz. Bu, PersonService art─▒k nas─▒l bir yaratma konusunda endi┼čelenmenize gerek olmad─▒─č─▒ anlam─▒na gelir, GroupMembershipService sadece verilenleri kabul eder ve onlarla ├žal─▒┼č─▒r. Bu ayn─▒ zamanda bir alt s─▒n─▒f─▒d─▒r bunun bir anlam─▒ GroupMembershipService veya aletlerin GroupMembershipService aray├╝z├╝ i├žine "enjekte" olabilir PersonService ve PersonService de─či┼čim hakk─▒nda bilmek gerekmez.


255







Kabul edilen cevap iyi bir cevap - ancak ┼čunu da belirtmek isterim ki, DI kodda kodlanm─▒┼č sabitlerden ka├ž─▒n─▒lan klasikten ├žok uzakt─▒r.

Bir veritaban─▒ ad─▒ gibi bir sabit kulland─▒─č─▒n─▒zda, onu kodun i├žinden h─▒zl─▒ bir ┼čekilde baz─▒ config dosyas─▒na ta┼č─▒r ve bu de─čeri i├žeren bir de─či┼čkeni gereken yere iletirsiniz. Bunu yapman─▒n nedeni, bu sabitlerin genellikle kodun geri kalan─▒ndan daha s─▒k de─či┼čmesidir. ├ľrne─čin, kodu bir test veritaban─▒nda test etmek istiyorsan─▒z.

DI, Nesne Y├Ânelimli programlama d├╝nyas─▒nda buna benzer. Sabit de─či┼čmezler yerine oradaki de─čerler b├╝t├╝n nesnelerdir - ancak bunlar─▒ olu┼čturan kodun s─▒n─▒f kodundan ├ž─▒karmas─▒n─▒n nedeni benzerdir - nesneler bunlar─▒ kullanan koddan daha s─▒k de─či┼čir. B├Âyle bir de─či┼čimin gerekli oldu─ču ├Ânemli bir durum testlerdir.


163


2011-01-06





Araba ve Motor dersleriyle basit bir ├Ârnek deneyelim , herhangi bir araban─▒n en az─▒ndan ┼čimdilik, herhangi bir yere gitmek i├žin bir motora ihtiyac─▒ var. Yani kod ba─č─▒ml─▒l─▒k enjeksiyonu olmadan nas─▒l g├Âr├╝nece─či a┼ča─č─▒da.

 public class Car
{
    public Car()
    {
        GasEngine engine = new GasEngine();
        engine.Start();
    }
}

public class GasEngine
{
    public void Start()
    {
        Console.WriteLine("I use gas as my fuel!");
    }
}
 

Ve Car s─▒n─▒f─▒n─▒ ba┼člatmak i├žin bir sonraki kodu kullanaca─č─▒z:

 Car car = new Car();
 

Bu kodla ilgili olarak GasEngine ile s─▒k─▒ bir ┼čekilde birle┼čti─čimiz ve e─čer bunu ElectricityEngine olarak de─či┼čtirmeye karar verirsek, o zaman Araba s─▒n─▒f─▒n─▒ yeniden yazmam─▒z gerekecek. Uygulama b├╝y├╝d├╝k├že, daha fazla sorun ve ba┼č a─čr─▒s─▒ da yeni tip motor eklemek ve kullanmak zorunda kalaca─č─▒z.

Bir ba┼čka deyi┼čle, bu yakla┼č─▒mla ├╝st d├╝zey Car s─▒n─▒f─▒m─▒z─▒n, SOLID'den Ba─č─▒ml─▒l─▒k ─░nversiyon Prensibi'ni (DIP) ihlal eden daha d├╝┼č├╝k seviyeli GasEngine s─▒n─▒f─▒na ba─čl─▒ olmas─▒. DIP, somut s─▒n─▒flara de─čil soyutlamalara g├╝venmemiz gerekti─čini ├Âne s├╝r├╝yor. Bu nedenle, bunu kar┼č─▒lamak i├žin IEngine aray├╝z├╝n├╝ tan─▒t─▒yoruz ve a┼ča─č─▒daki gibi bir kod yaz─▒yoruz:

     public interface IEngine
    {
        void Start();
    }

    public class GasEngine : IEngine
    {
        public void Start()
        {
            Console.WriteLine("I use gas as my fuel!");
        }
    }

    public class ElectricityEngine : IEngine
    {
        public void Start()
        {
            Console.WriteLine("I am electrocar");
        }
    }

    public class Car
    {
        private readonly IEngine _engine;
        public Car(IEngine engine)
        {
            _engine = engine;
        }

        public void Run()
        {
            _engine.Start();
        }
    }
 

Art─▒k Car s─▒n─▒f─▒, belirli bir motor uygulamas─▒na de─čil, yaln─▒zca IEngine aray├╝z├╝ne ba─čl─▒d─▒r. ┼×imdi, tek p├╝f noktas─▒ nas─▒l bir otomobil ├Ârne─či yarataca─č─▒z ve ona GasEngine veya ElectricityEngine gibi ger├žek bir somut Motor s─▒n─▒f─▒ verece─čiz. Ba─č─▒ml─▒l─▒k Enjeksiyonu burada devreye giriyor.

    Car gasCar = new Car(new GasEngine());
   gasCar.Run();
   Car electroCar = new Car(new ElectricityEngine());
   electroCar.Run();
 

Burada temel olarak ba─č─▒ml─▒l─▒─č─▒m─▒z─▒ (Engine ├Ârne─či) Car yap─▒c─▒s─▒na enjekte ederiz (ge├žer). ┼×imdi s─▒n─▒flar─▒m─▒z nesneler ve onlar─▒n ba─č─▒ml─▒l─▒klar─▒ aras─▒nda gev┼ček bir ba─ča sahip, ve Car s─▒n─▒f─▒n─▒ de─či┼čtirmeden kolayca yeni motor tipleri ekleyebiliriz.

S─▒n─▒flar─▒n daha gev┼ček bir ┼čekilde ba─članm─▒┼č olmas─▒ Ba─č─▒ml─▒l─▒k Enjeksiyonunun as─▒l yarar─▒ , ├ž├╝nk├╝ zor kodlanm─▒┼č ba─č─▒ml─▒l─▒klar─▒ yoktur. Bu yukar─▒da belirtilen Ba─č─▒ml─▒l─▒k ─░nversiyon Prensibi'ni izler. Belirli uygulamalara g├Ânderme yapmak yerine, s─▒n─▒flar, s─▒n─▒f olu┼čturuldu─čunda kendilerine sa─članan soyutlamalar─▒ (genellikle aray├╝zler ) ister.

Sonu├žta Ba─č─▒ml─▒l─▒k enjeksiyonu , nesneler ve onlar─▒n ba─č─▒ml─▒l─▒klar─▒ aras─▒nda gev┼ček birle┼čme sa─člamak i├žin sadece bir tekniktir. S─▒n─▒f─▒n eylemlerini ger├žekle┼čtirmek i├žin ihtiya├ž duydu─ču ba─č─▒ml─▒l─▒klar─▒ do─črudan somutla┼čt─▒rmak yerine, ba─č─▒ml─▒l─▒klar s─▒n─▒fa (en s─▒k) yap─▒c─▒ enjeksiyonuyla sa─član─▒r.

Ayr─▒ca bir├žok ba─č─▒ml─▒l─▒─ča sahip oldu─čumuzda, t├╝m ba─č─▒ml─▒l─▒klar─▒m─▒z i├žin hangi aray├╝zlerin hangi somut uygulamalarla e┼čle┼čtirilece─čini ve hangi ba─č─▒ml─▒l─▒klar─▒n yap─▒laca─č─▒n─▒ belirleyebilece─čimizi s├Âyleyebilece─čimiz Inversion of Control (IoC) konteyn─▒rlar─▒n─▒ kullanmak ├žok iyi bir uygulamad─▒r. Amac─▒m─▒z. ├ľrne─čin, bu IoC kapsay─▒c─▒ i├žin e┼člemenizde belirtebilirsiniz IEngine ba─č─▒ml─▒l─▒k aktar─▒lmas─▒ gerekti─čini GasEngine s─▒n─▒f ve bizim bir ├Ârne─či i├žin IoC kapsay─▒c─▒ sordu─čunuzda Araba s─▒n─▒f─▒n─▒n, otomatik bizim in┼ča edecek Araba bir ile s─▒n─▒f GasEngine ba─č─▒ml─▒l─▒k ge├žti.

G├ťNCELLEME: Ge├ženlerde Julie Lerman'dan EF Core hakk─▒nda bir kurs izledim ve DI ile ilgili k─▒sa tan─▒m─▒n─▒ be─čendim.

Ba─č─▒ml─▒l─▒k enjeksiyonu, uygulaman─▒z─▒n an─▒nda bu nesneleri bu nesnelerden sorumlu olmaya zorlamadan, ihtiyac─▒ olan s─▒n─▒flara nesneleri enjekte etmesine izin veren bir kal─▒pt─▒r. Kodunuzun daha gev┼ček bir ┼čekilde ba─članmas─▒na olanak tan─▒r ve Entity Framework Core bu ayn─▒ hizmet sistemine ba─član─▒r.


121







Bal─▒─ča gitmek istedi─činizi d├╝┼č├╝nelim:

  • Ba─č─▒ml─▒l─▒k enjeksiyonu olmadan, her ┼čeye kendiniz bakman─▒z gerekir. Bir tekne bulman─▒z, bir olta sat─▒n almak, yem aramak, vb. Gerekir. Bu elbette m├╝mk├╝nd├╝r, ancak size ├žok fazla sorumluluk y├╝kler. Yaz─▒l─▒m a├ž─▒s─▒ndan, t├╝m bu ┼čeyleri araman─▒z gerekti─či anlam─▒na gelir.

  • Ba─č─▒ml─▒l─▒k enjeksiyonuyla, bir ba┼čkas─▒ t├╝m haz─▒rl─▒klara ├Âzen g├Âsterir ve gerekli ekipman─▒ size sunar. Kullan─▒ma haz─▒r olan tekneyi, oltay─▒ ve yemi alacaks─▒n─▒z ("enjekte edilecek").


107







Bu hakk─▒nda en basit bir a├ž─▒klama Ba─č─▒ml─▒l─▒k Enjeksiyon ve Ba─č─▒ml─▒l─▒k Enjeksiyon Konteyner g├Ârd├╝─č├╝m:

Ba─č─▒ml─▒l─▒k Enjeksiyonu Olmadan

  • Uygulama, Foo'ya (├Ârne─čin bir denetleyici) ihtiya├ž duyuyor, yani:
  • Uygulama Foo olu┼čturur
  • Uygulama Foo ├ža─č─▒r─▒yor
    • Foo'nun Bar'a ihtiyac─▒ var (├Âr. Bir servis), bu y├╝zden:
    • Foo Bar yarat─▒yor
    • Foo Bar ├ža─č─▒r─▒r
      • Bar, Bim'e (bir hizmet, bir depo,ÔÇŽ) ihtiya├ž duyuyor, yani:
      • Bar Bim'i yaratt─▒
      • Bar bir ┼čey yapar

Ba─č─▒ml─▒l─▒k Enjeksiyonu ile

  • Uygulama Bim'e ihtiya├ž duyan Bar'a ihtiya├ž duyan Foo'ya ihtiya├ž duyuyor:
  • Uygulama Bim olu┼čturur
  • Uygulama Bar olu┼čturur ve Bim verir
  • Uygulama Foo olu┼čturur ve Bar verir
  • Uygulama Foo ├ža─č─▒r─▒yor
    • Foo Bar ├ža─č─▒r─▒r
      • Bar bir ┼čey yapar

Ba─č─▒ml─▒l─▒k Enjeksiyon Kab─▒ Kullanma

  • Uygulama b├Âylece Foo'ya ihtiya├ž duyar:
  • Uygulama Konteyn─▒rdan Foo al─▒r, yani:
    • Konteyner Bim yarat─▒yor
    • Container Bar yarat─▒r ve Bim verir
    • Container Foo yarat─▒r ve Bar'─▒ verir
  • Uygulama Foo ├ža─č─▒r─▒yor
    • Foo Bar ├ža─č─▒r─▒r
      • Bar bir ┼čey yapar

Ba─č─▒ml─▒l─▒k Enjeksiyonu ve Ba─č─▒ml─▒l─▒k Enjeksiyon Konteynerleri farkl─▒ ┼čeylerdir:

  • Ba─č─▒ml─▒l─▒k Enjeksiyonu daha iyi kod yazmak i├žin bir y├Ântemdir
  • DI Kapsay─▒c─▒ ba─č─▒ml─▒l─▒klar─▒ enjekte etmeye yard─▒mc─▒ olan bir ara├žt─▒r

Ba─č─▒ml─▒l─▒k enjeksiyonunu yapmak i├žin bir kaba ihtiyac─▒n─▒z yok. Ancak bir konteyner size yard─▒mc─▒ olabilir.


96


2016-05-05





ÔÇťBa─č─▒ml─▒l─▒k enjeksiyonuÔÇŁ sadece parametrele┼čtirilmi┼č kurucular ve halka a├ž─▒klay─▒c─▒lar kullanmak anlam─▒na gelmiyor mu?

James Shore'nin makalesi kar┼č─▒la┼čt─▒rma i├žin a┼ča─č─▒daki ├Ârnekleri g├Âstermektedir .

Ba─č─▒ml─▒l─▒k enjeksiyonu olmayan yap─▒c─▒:

 public class Example { 
  private DatabaseThingie myDatabase; 

  public Example() { 
    myDatabase = new DatabaseThingie(); 
  } 

  public void doStuff() { 
    ... 
    myDatabase.getData(); 
    ... 
  } 
} 
 

Ba─č─▒ml─▒l─▒k enjeksiyonlu yap─▒c─▒:

 public class Example { 
  private DatabaseThingie myDatabase; 

  public Example(DatabaseThingie useThisDatabaseInstead) { 
    myDatabase = useThisDatabaseInstead; 
  }

  public void doStuff() { 
    ... 
    myDatabase.getData(); 
    ... 
  } 
}
 

51







Ba─č─▒ml─▒l─▒k Enjeksiyonu kavram─▒n─▒n anla┼č─▒lmas─▒n─▒ kolayla┼čt─▒rmak. Bir ampul├╝ de─či┼čtirmek (a├žmak / kapatmak) i├žin anahtar d├╝─čmesine bir ├Ârnek verelim.

Ba─č─▒ml─▒l─▒k Enjeksiyonu Olmadan

Anahtar─▒n hangi ampule ba─čl─▒ oldu─čumu bilmesi gerekir (kodlanm─▒┼č ba─č─▒ml─▒l─▒k). Yani,

Anahtar -> Kal─▒c─▒Bulb // anahtar do─črudan kal─▒c─▒ ampule ba─član─▒r, test i┼člemi kolay m├╝mk├╝n de─čildir




 Switch(){
PermanentBulb = new Bulb();
PermanentBulb.Toggle();
}
 

Ba─č─▒ml─▒l─▒k Enjeksiyonu ile

Anahtar sadece bana hangi ampul├╝n ge├žti─čini a├žmak / kapatmak zorunda oldu─čumu biliyor. Yani,

Switch -> Bulb1 VEYA Bulb2 VEYA NightBulb (enjekte edilen ba─č─▒ml─▒l─▒k)




 Switch(AnyBulb){ //pass it whichever bulb you like
AnyBulb.Toggle();
}
 

Anahtar ve Ampul i├žin James ├ľrne─čini De─či┼čtirme :

 public class SwitchTest { 
  TestToggleBulb() { 
    MockBulb mockbulb = new MockBulb(); 

    // MockBulb is a subclass of Bulb, so we can 
    // "inject" it here: 
    Switch switch = new Switch(mockBulb); 

    switch.ToggleBulb(); 
    mockBulb.AssertToggleWasCalled(); 
  } 
}

public class Switch { 
  private Bulb myBulb; 

  public Switch() { 
    myBulb = new Bulb(); 
  } 

  public Switch(Bulb useThisBulbInstead) { 
    myBulb = useThisBulbInstead; 
  } 

  public void ToggleBulb() { 
    ... 
    myBulb.Toggle(); 
    ... 
  } 
}`
 

36







Ba─č─▒ml─▒l─▒k Enjeksiyonu (DI) Nedir?

Di─čerlerinin dedi─či gibi, Ba─č─▒ml─▒l─▒k Enjeksiyonu (DI) , ilgilenilen s─▒n─▒f─▒m─▒z─▒n (t├╝ketici s─▒n─▒f─▒) ba─č─▒ml─▒ oldu─ču di─čer nesne ├Ârneklerinin ( UML anlam─▒nda ) do─črudan yarat─▒lmas─▒ ve kullan─▒m ├Âmr├╝n├╝n sorumlulu─čunu ortadan kald─▒r─▒r . Bu ├Ârnekler bunun yerine t├╝ketici s─▒n─▒f─▒m─▒za ge├žirilir, tipik olarak yap─▒c─▒ parametreleri veya m├╝lk belirleyiciler arac─▒l─▒─č─▒yla (t├╝ketici s─▒n─▒f─▒na giren ve t├╝ketici s─▒n─▒f─▒na ge├žen ba─č─▒ml─▒l─▒k nesnesinin y├Ânetimi genellikle bir Inversion of Control (IoC) kab─▒ taraf─▒ndan ger├žekle┼čtirilir , ancak bu ba┼čka bir konudur) .

DI, DIP ve KATI

├ľzellikle, Robert C Martin'in paradigma Tasar─▒m Odakl─▒ Nesne KATI ilkelerine , DI olas─▒ uygulamalar─▒ndan biridir Ba─č─▒ml─▒l─▒k Inversion ─░lke (DIP) . DIP oldu─ču D bir SOLID mantra di─čer DIP uygulamalar─▒ Servis Locator ve Eklenti desenleri - bulunur.

DIP'nin amac─▒, s─▒n─▒flar aras─▒nda s─▒k─▒, somut ba─č─▒ml─▒l─▒klar─▒n ayr─▒┼čt─▒r─▒lmas─▒ ve bunun yerine, kullan─▒lan diline ve yakla┼č─▒ma ba─čl─▒ olarak interface , bir abstract class veya bir soyutlama yoluyla ba─članman─▒n gev┼četilmesidir pure virtual class .

DIP olmadan, kodumuz (bu 't├╝keten s─▒n─▒f' olarak adland─▒rd─▒m) do─črudan somut bir ba─č─▒ml─▒l─▒kla birle┼čtirilir ve ayr─▒ca genellikle bu ba─č─▒ml─▒l─▒─č─▒n bir ├Ârne─čini nas─▒l elde edece─činizi ve y├Ânetece─činizi bilme sorumlulu─čuyla y├╝klenir: yani kavramsal olarak:

 "I need to create/use a Foo and invoke method `GetBar()`"
 

DIP uygulamas─▒ndan sonra, gereksinim gev┼četilir ve Foo ba─č─▒ml─▒l─▒─č─▒n ├Âmr├╝n├╝ elde etme ve y├Ânetme kayg─▒s─▒ kald─▒r─▒lm─▒┼čt─▒r:

 "I need to invoke something which offers `GetBar()`"
 

DIP (ve DI) neden kullan─▒lmal─▒?

Bu ┼čekilde s─▒n─▒flar aras─▒ndaki ba─č─▒ml─▒l─▒klar─▒n ayr─▒┼čt─▒r─▒lmas─▒ , bu ba─č─▒ml─▒l─▒k s─▒n─▒flar─▒n─▒n soyutlaman─▒n ├Ân ko┼čullar─▒n─▒ da yerine getiren ba┼čka uygulamalarla kolayca de─či┼čtirilmesine izin verir (├Ârne─čin, ba─č─▒ml─▒l─▒k ayn─▒ aray├╝z├╝n ba┼čka bir uygulamas─▒ ile de─či┼čtirilebilir). Di─čerleri de s├Âyledi─čim gibi Dahas─▒, muhtemelen DIP yoluyla Decouple s─▒n─▒flar─▒na en yayg─▒n nedeni bir t├╝keten s─▒n─▒f bu ayn─▒ ba─č─▒ml─▒l─▒klar art─▒k stubbed edilebilece─či gibi, izolasyon test edilmi┼č ve / veya alay edilecek sa─člamakt─▒r.

DI'nin bir sonucu, ba─č─▒ml─▒l─▒k nesnesi ├Ârneklerinin ya┼čam boyu y├Ânetiminin art─▒k ba─č─▒ml─▒l─▒k nesnesi art─▒k t├╝ketici s─▒n─▒f─▒na ge├žirildi─či i├žin (yap─▒c─▒ veya ayarlay─▒c─▒ enjeksiyon yoluyla) art─▒k bir t├╝ketici s─▒n─▒f taraf─▒ndan kontrol edilmemesidir.

Bu farkl─▒ ┼čekillerde g├Âr├╝lebilir:

  • T├╝ketici s─▒n─▒f─▒n─▒n ├Âm├╝r boyu ba─č─▒ml─▒l─▒k kontrol├╝n├╝n korunmas─▒ gerekiyorsa, ba─č─▒ml─▒l─▒k s─▒n─▒f─▒ ├Ârneklerini olu┼čturmak i├žin t├╝ketici s─▒n─▒f─▒na bir (soyut) fabrika enjekte edilerek kontrol yeniden tesis edilebilir. T├╝ketici Create , fabrikada gerekti─či gibi ├Ârnekleri alabilecek ve bu ├Ârnekleri tamamland─▒ktan sonra elden ├ž─▒karabilecektir .
  • Veya, ba─č─▒ml─▒l─▒k ├Ârneklerinin ├Âm├╝r boyu kontrol├╝ bir IoC kab─▒na b─▒rak─▒labilir (a┼ča─č─▒da daha fazlas─▒ var).

DI ne zaman kullan─▒l─▒r?

  • Muhtemelen e┼čde─čer bir uygulama i├žin bir ba─č─▒ml─▒l─▒k yerine ihtiya├ž duyulacaksa,
  • ├ťniteyi test etmeniz gereken her zaman, bir s─▒n─▒f─▒n metotlar─▒n─▒ ba─č─▒ml─▒l─▒klar─▒n─▒ izole ederek test etmek,
  • Bir ba─č─▒ml─▒l─▒─č─▒n kullan─▒m ├Âmr├╝n├╝n belirsizli─či deneyi zorunlu k─▒labilirse (├Ârne─čin, Hey, MyDepClass i┼č par├žac─▒─č─▒ g├╝venli midir - ya bunu bir tekil yap─▒p ayn─▒ ├Ârne─či t├╝m t├╝keticilere enjekte edersek?)

├ľrnek

─░┼čte basit bir C # uygulamas─▒. A┼ča─č─▒da T├╝ketici s─▒n─▒f─▒ verilmi┼čtir:

 public class MyLogger
{
   public void LogRecord(string somethingToLog)
   {
      Console.WriteLine("{0:HH:mm:ss} - {1}", DateTime.Now, somethingToLog);
   }
}
 

Her ne kadar g├Âr├╝n├╝┼čte zarars─▒z gibi g├Âr├╝nse de, static di─čer iki s─▒n─▒fa iki ba─č─▒ml─▒l─▒─č─▒ vard─▒r System.DateTime ve System.Console yaln─▒zca g├╝nl├╝─če kaydetme ├ž─▒kt─▒ se├ženeklerini s─▒n─▒rland─▒rmakla kalmaz (konsolda oturum a├žmak kimse izlemiyorsa de─čersizdir), ama daha k├Ât├╝s├╝, ba─č─▒ml─▒l─▒─č─▒ g├Âz ├Ân├╝ne al─▒nd─▒─č─▒nda otomatik olarak test etmek zordur deterministik olmayan bir sistem saati.

Bununla birlikte DIP , bu s─▒n─▒fa, ba─č─▒ml─▒l─▒k olarak zaman damgalama endi┼česini ortadan kald─▒rarak ve MyLogger sadece basit bir aray├╝ze ba─članarak uygulayabiliriz:

 public interface IClock
{
    DateTime Now { get; }
}
 

Ayn─▒ zamanda Console a gibi bir soyutlamaya olan ba─č─▒ml─▒l─▒─č─▒ da gev┼četebiliriz TextWriter . Ba─č─▒ml─▒l─▒k Enjeksiyonu tipik olarak constructor enjeksiyon (bir soyutlamay─▒ t├╝ketici s─▒n─▒f─▒n─▒n yap─▒c─▒s─▒ olarak bir ba─č─▒ml─▒l─▒─ča bir soyutlamay─▒ ileterek) ya da Setter Injection (ba─č─▒ml─▒l─▒─č─▒ bir setXyz() pasif veya bir Net ├ľzelli─či ile {set;} tan─▒mlanm─▒┼č olarak ge├žirerek ) uygulan─▒r. Yap─▒c─▒ Enjeksiyonu tercih edilir, ├ž├╝nk├╝ bu s─▒n─▒f─▒n in┼čaattan sonra do─čru durumda olmas─▒n─▒ ve i├ž ba─č─▒ml─▒l─▒k alanlar─▒n─▒n readonly (C #) veya final (Java) olarak i┼čaretlenmesini sa─člar . Bu y├╝zden yukar─▒daki ├Ârnekte yap─▒c─▒ enjeksiyonunu kullanmak, bizi ┼ču ┼čekilde b─▒rak─▒r:

 public class MyLogger : ILogger // Others will depend on our logger.
{
    private readonly TextWriter _output;
    private readonly IClock _clock;

    // Dependencies are injected through the constructor
    public MyLogger(TextWriter stream, IClock clock)
    {
        _output = stream;
        _clock = clock;
    }

    public void LogRecord(string somethingToLog)
    {
        // We can now use our dependencies through the abstraction 
        // and without knowledge of the lifespans of the dependencies
        _output.Write("{0:yyyy-MM-dd HH:mm:ss} - {1}", _clock.Now, somethingToLog);
    }
}
 

( Clock Tabii ki geri d├Ânebilecek bir beton sa─članmal─▒ DateTime.Now ve iki ba─č─▒ml─▒l─▒k da bir yap─▒c─▒ enjeksiyon yoluyla bir IoC kab─▒ taraf─▒ndan sa─članmal─▒)

Art─▒k ba─č─▒ml─▒l─▒klar ├╝zerinde kontrol├╝m├╝z oldu─ču i├žin g├╝nl├╝─č├╝m├╝z├╝n do─čru ├žal─▒┼čt─▒─č─▒n─▒ kesin olarak kan─▒tlayan otomatik bir Birim Testi olu┼čturulabilir, ├ž├╝nk├╝ zaman ve yaz─▒l─▒ ├ž─▒kt─▒ya g├Âz atabiliriz:

 [Test]
public void LoggingMustRecordAllInformationAndStampTheTime()
{
    // Arrange
    var mockClock = new Mock<IClock>();
    mockClock.Setup(c => c.Now).Returns(new DateTime(2015, 4, 11, 12, 31, 45));
    var fakeConsole = new StringWriter();

    // Act
    new MyLogger(fakeConsole, mockClock.Object)
        .LogRecord("Foo");

    // Assert
    Assert.AreEqual("2015-04-11 12:31:45 - Foo", fakeConsole.ToString());
}
 

Sonraki ad─▒mlar

Ba─č─▒ml─▒l─▒k enjeksiyonu, somut ba─č─▒ml─▒l─▒k ├Ârneklerini enjekte etmek (sa─člamak) ve ya┼čam s├╝resi ├Ârneklerini y├Ânetmek i├žin bir ─░nversiyon Kontrol kab─▒ (IoC) ile her zaman ili┼čkilidir . Yap─▒land─▒rma / ├Âny├╝kleme i┼člemi s─▒ras─▒nda, IoC kaplar a┼ča─č─▒dakilerin tan─▒mlanmas─▒na izin verir:

  • Her bir soyutlama ve yap─▒land─▒r─▒lm─▒┼č somut uygulama aras─▒nda haritalama (├Ârne─čin , bir t├╝ketici ne zaman isterse IBar , bir ConcreteBar ├Ârnek getirsin )
  • Her ba─č─▒ml─▒l─▒─č─▒n ya┼čam boyu y├Ânetimi i├žin, ├Ârne─čin her t├╝ketici ├Ârne─či i├žin yeni bir nesne olu┼čturmak, t├╝m t├╝keticilerdeki tekli bir ba─č─▒ml─▒l─▒k ├Ârne─čini payla┼čmak, ayn─▒ ba─č─▒ml─▒l─▒k ├Ârne─čini yaln─▒zca ayn─▒ i┼č par├žac─▒─č─▒nda payla┼čmak, vb. i├žin politikalar belirlenebilir.
  • Net'te IoC konteynerleri , yap─▒land─▒r─▒lm─▒┼č ├Âm├╝r y├Ânetimi ile paralel IDisposable olarak Disposing ba─č─▒ml─▒l─▒klar─▒n sorumlulu─čunu ├╝stlenecek gibi protokollerin fark─▒ndad─▒r .

Tipik olarak, IoC kaplar─▒ bir kez konfig├╝re edildikten / ├Âny├╝klendikten sonra, kodlay─▒c─▒ya ba─č─▒ml─▒l─▒klardan endi┼če etmek yerine eldeki koda odaklanmas─▒na izin veren arka planda sorunsuz ┼čekilde ├žal─▒┼č─▒rlar.

DI-dostu kodun anahtar─▒, s─▒n─▒flar─▒n statik birle┼čtirilmesinden ka├ž─▒nmak ve Ba─č─▒ml─▒l─▒klar olu┼čturmak i├žin new () kullanmamakt─▒r.

Yukar─▒daki ├Ârnekte oldu─ču gibi, ba─č─▒ml─▒l─▒klar─▒n ├ž├Âz├╝lmesi baz─▒ tasar─▒m ├žabalar─▒ gerektirir ve geli┼čtirici i├žin, new ba─č─▒ml─▒l─▒klar─▒ do─črudan yapma al─▒┼čkanl─▒─č─▒n─▒ ortadan kald─▒rmak ve bunun yerine ba─č─▒ml─▒l─▒klar─▒ y├Ânetmek i├žin kaba g├╝venmek i├žin gereken bir paradigma kaymas─▒ vard─▒r .

Fakat faydalar ├žoktur, ├Âzellikle de ilgi alan─▒n─▒z─▒ tamamen s─▒namak i├žin.

Not : olu┼čturma / e┼čle┼čtirme / ├ž─▒k─▒nt─▒ (yoluyla new ..() POCO / POJO / Seri DTOS / varl─▒k Grafikler / Anonim JSON ├ž─▒k─▒nt─▒lar ve di─čerleri) - yani, "veriler sadece" s─▒n─▒flar veya kay─▒tlar─▒ - kullan─▒labilir veya y├Ântem d├Ând├╝r├╝len de─čil de (ba─č─▒ml─▒l─▒klar olarak UML anlamda) ve DI'ye tabi de─čildir. new Bunlar─▒ yans─▒tmak i├žin kullanmak gayet iyi.


36







Ba─č─▒ml─▒l─▒k Enjeksiyonunun (DI) b├╝t├╝n amac─▒ uygulama kaynak kodunu temiz ve istikrarl─▒ tutmakt─▒r :

  • ba─č─▒ml─▒l─▒k ba┼člatma kodunu temizleme
  • kullan─▒lan ba─č─▒ml─▒l─▒─ča bakmaks─▒z─▒n istikrarl─▒

Pratik olarak, her tasar─▒m deseni gelecekteki de─či┼čikliklerin minimum dosyalar─▒ etkilemesi i├žin endi┼čeleri ay─▒r─▒r.

DI'nin ├Âzel alan─▒, ba─č─▒ml─▒l─▒k yap─▒land─▒rmas─▒ ve ilklendirmenin delegesidir.

├ľrnek: Kabuk beti─či ile DI

Zaman zaman Java d─▒┼č─▒nda ├žal─▒┼č─▒yorsan─▒z source , bir├žok betik dilinde (Shell, Tcl vb., Hatta import Python'da bu ama├ž i├žin yanl─▒┼č kullan─▒lan) bile nas─▒l kullan─▒ld─▒─č─▒n─▒ hat─▒rlay─▒n .

Basit dependent.sh komut dosyas─▒ d├╝┼č├╝n├╝n :

 #!/bin/sh
# Dependent
touch         "one.txt" "two.txt"
archive_files "one.txt" "two.txt"
 

Komut dosyas─▒ ba─č─▒ml─▒d─▒r: kendi ba┼č─▒na ba┼čar─▒l─▒ bir ┼čekilde y├╝r├╝t├╝lmez ( archive_files tan─▒mlanmam─▒┼č).

Sen tan─▒mlamak archive_files i├žinde archive_files_zip.sh (kullanarak uygulama komut zip bu durumda):

 #!/bin/sh
# Dependency
function archive_files {
    zip files.zip "[email protected]"
}
 

source -─░ng uygulama komut dosyas─▒n─▒ do─črudan ba─č─▒ml─▒ olan─▒n yerine kullanmak yerine, injector.sh her iki "bile┼čeni" saran bir "kapsay─▒c─▒" kullan─▒rs─▒n─▒z :

 #!/bin/sh 
# Injector
source ./archive_files_zip.sh
source ./dependent.sh
 

archive_files Ba─č─▒ml─▒l─▒k sadece edilmi┼č enjekte i├žine ba─č─▒ml─▒ senaryo.

Sen uygular ba─č─▒ml─▒l─▒k enjekte olabilirdi archive_files kullanarak tar veya xz .

├ľrnek: DI'yi ├ž─▒karma

E─čer dependent.sh komut do─črudan ba─č─▒ml─▒l─▒klar─▒ kullan─▒lan yakla┼č─▒m aranmak ba─č─▒ml─▒l─▒k aramas─▒ (tersidir ba─č─▒ml─▒l─▒k enjeksiyon ):

 #!/bin/sh
# Dependent

# dependency look-up
source ./archive_files_zip.sh

touch         "one.txt" "two.txt"
archive_files "one.txt" "two.txt"
 

┼×imdi sorun ┼ču ki, ba─č─▒ml─▒ "bile┼čen" ba┼člatma i┼člemini kendisi yapmak zorunda.

"Bile┼čen" in kaynak kodu ne temiz , ne de kararl─▒ de─čil ├ž├╝nk├╝ ba─č─▒ml─▒l─▒klar─▒n ba┼člat─▒lmas─▒ndaki her de─či┼čiklik "bile┼čenler" in kaynak kod dosyas─▒ i├žin de yeni s├╝r├╝mler gerektiriyor.

Son s├Âzler

DI, Java ├žer├ževelerinde oldu─ču gibi b├╝y├╝k ├Âl├ž├╝de vurgulanm─▒┼č ve pop├╝ler de─čildir.

Ancak, endi┼čelerini b├Âlmek i├žin genel bir yakla┼č─▒m:

  • uygulama geli┼čtirme ( tek kaynak kodu s├╝r├╝m ya┼čam d├Âng├╝s├╝)
  • uygulama da─č─▒t─▒m─▒ ( ba─č─▒ms─▒z ya┼čam d├Âng├╝leri olan birden fazla hedef ortam)

Konfig├╝rasyonun yaln─▒zca ba─č─▒ml─▒l─▒k aramas─▒nda kullan─▒lmas─▒ , konfig├╝rasyon parametrelerinin say─▒s─▒ ba─č─▒ml─▒l─▒k ba┼č─▒na de─či┼čebilir (├Âr. Yeni kimlik do─črulama t├╝r├╝) ve desteklenen ba─č─▒ml─▒l─▒k say─▒s─▒ (├Âr. Yeni veritaban─▒ t├╝r├╝) de─či┼čebilir.


25







Yukar─▒daki t├╝m cevaplar iyidir, amac─▒m kavram─▒ basit bir ┼čekilde a├ž─▒klamakt─▒r, b├Âylece programlama bilgisi olmayan herkes de kavram─▒ anlayabilir

Ba─č─▒ml─▒l─▒k enjeksiyonu, karma┼č─▒k sistemleri daha basit bir ┼čekilde olu┼čturmam─▒za yard─▒mc─▒ olan tasar─▒m modellerinden biridir.

G├╝n├╝m├╝z hayat─▒nda bu kal─▒b─▒n ├žok ├že┼čitli uygulamalar─▒n─▒ g├Ârebiliriz. ├ľrneklerden baz─▒lar─▒ Teyp, VCD, CD S├╝r├╝c├╝ vb.


Reel-to-reel ta┼č─▒nabilir kay─▒t cihaz─▒, 20. y├╝zy─▒l─▒n ortalar─▒nda.

Yukar─▒daki resim, 20. y├╝zy─▒l─▒n ortalar─▒nda, Reel-reel portatif ses kay─▒t cihaz─▒n─▒n bir g├Âr├╝nt├╝s├╝d├╝r. Kaynak .

Bir teyp makinesinin birincil amac─▒, sesi kaydetmek veya ├žalmakt─▒r.

Bir sistemi tasarlarken, ses veya m├╝zik kaydetmek veya ├žalmak i├žin bir makaraya ihtiya├ž duyar. Bu sistemi tasarlaman─▒n iki yolu var.

  1. Makaray─▒ makinenin i├žine yerle┼čtirebiliriz
  2. Makaraya yerle┼čtirilebilece─či bir kanca sa─člayabiliriz.

─░lki kullan─▒rsak, makaray─▒ de─či┼čtirmek i├žin makineyi a├žmam─▒z gerekir. ikinciyi tercih edersek, bu makara i├žin bir kanca yerle┼čtirirse, makaray─▒ de─či┼čtirerek herhangi bir m├╝zik ├žalman─▒n ek bir avantaj─▒n─▒ elde ederiz. ve ayr─▒ca sadece makaradaki herhangi bir ┼čeyi ├žalmak i├žin i┼člevi azaltmak.

Ak─▒ll─▒ca ba─č─▒ml─▒l─▒k enjeksiyonu gibi, ba─č─▒ms─▒z bile┼čenlerin karma┼č─▒k bir sistem olu┼čturmak ├╝zere bir araya getirilebilmesi i├žin sadece bile┼čenin spesifik i┼člevselli─čine odaklanmak i├žin ba─č─▒ml─▒l─▒klar─▒n d─▒┼čsalla┼čt─▒r─▒lmas─▒ i┼člemidir.

Ba─č─▒ml─▒l─▒k enjeksiyonunu kullanarak elde etti─čimiz temel faydalar.

  • Y├╝ksek yap─▒┼čma ve gev┼ček ba─člant─▒.
  • Ba─č─▒ml─▒l─▒─č─▒ d─▒┼člamak ve sadece sorumlulu─ču aramak.
  • Bir ┼čeyleri bile┼čen olarak yapmak ve y├╝ksek yeteneklere sahip b├╝y├╝k bir sistemler olu┼čturmak i├žin birle┼čtirmek.
  • Ba─č─▒ms─▒z bir ┼čekilde geli┼čtirildiklerinden, do─čru bir ┼čekilde test edildiklerinden, y├╝ksek kaliteli bile┼čenlerin geli┼čtirilmesine yard─▒mc─▒ olur.
  • Biri ba┼čar─▒s─▒z olursa, bile┼čenin bir ba┼čkas─▒yla de─či┼čtirilmesine yard─▒mc─▒ olur.

G├╝n├╝m├╝zde bu kavram programlama d├╝nyas─▒nda iyi bilinen ├žer├ževelerin temelini olu┼čturmaktad─▒r. Yay A├ž─▒s─▒ vb., Bu konseptin ├╝st├╝ne in┼ča edilmi┼č iyi bilinen yaz─▒l─▒m ├žer├ževeleridir.

Ba─č─▒ml─▒l─▒k enjeksiyonu, di─čer nesnelerin derleme zaman─▒nda bilmeden hangi nesnenin bu i┼člevselli─či sa─člamak i├žin kullan─▒laca─č─▒n─▒ bilmeden dayand─▒─č─▒ nesnelerin ├Ârneklerini olu┼čturmak i├žin kullan─▒lan bir kal─▒pt─▒r veya sadece bir nesneye ├Âzelliklerin enjekte edilmesine ba─č─▒ml─▒l─▒k enjeksiyonu denir.

Ba─č─▒ml─▒l─▒k enjeksiyonu ├Ârne─či

├ľnceden b├Âyle kod yaz─▒yoruz

 Public MyClass{
 DependentClass dependentObject
 /*
  At somewhere in our code we need to instantiate 
  the object with new operator  inorder to use it or perform some method.
  */ 
  dependentObject= new DependentClass();
  dependentObject.someMethod();
}
 

Ba─č─▒ml─▒l─▒k enjeksiyonu ile ba─č─▒ml─▒l─▒k enjekt├Âr├╝ bizim i├žin ba┼člatmay─▒ ortadan kald─▒racak

 Public MyClass{
 /* Dependency injector will instantiate object*/
 DependentClass dependentObject

 /*
  At somewhere in our code we perform some method. 
  The process of  instantiation will be handled by the dependency injector
 */ 

  dependentObject.someMethod();
}
 

Ayr─▒ca okuyabilir

Kontrol ─░nversiyonu ve Ba─č─▒ml─▒l─▒k Enjeksiyonu Aras─▒ndaki Fark


20







Ba─č─▒ml─▒l─▒k Enjeksiyonu Nedir?

Ba─č─▒ml─▒l─▒k Enjeksiyonu (DI), birbirine ba─čl─▒ olan nesneleri ay─▒rmak anlam─▒na gelir. Diyelim ki A nesnesi B Nesnesine ba─čl─▒ oldu─čundan, fikir bu nesneyi birbirinden ay─▒rmak. Derleme s├╝resine ra─čmen, nesneyi ├žal─▒┼čma zaman─▒nda nesnelere ba─č─▒ml─▒l─▒klar─▒ payla┼čmak yerine, yeni anahtar kelime kullanarak nesneyi zorlamak zorunda de─čiliz. Hakk─▒nda konu┼čursak

Ba─č─▒ml─▒l─▒k Enjeksiyonu ─░lkbaharda Nas─▒l ├çal─▒┼č─▒r:

Yeni anahtar kelime kullanarak nesneyi zorlamak zorunda de─čiliz, yap─▒land─▒rma dosyas─▒ndaki fasulye ba─č─▒ml─▒l─▒─č─▒n─▒ tan─▒mlamak yerine. Yayl─▒ kap, kancay─▒ takmaktan sorumlu olacakt─▒r.

Kontrolün Ters Çevirilmesi (IOC)

IOC genel bir kavramd─▒r ve bir├žok farkl─▒ ┼čekilde ifade edilebilir ve Ba─č─▒ml─▒l─▒k Enjeksiyonu, IOC'nin somut bir ├Ârne─čidir.

─░ki Ba─č─▒ml─▒l─▒k Enjeksiyonu t├╝r├╝:

  1. Yap─▒c─▒ Enjeksiyon
  2. Ayarlay─▒c─▒ Enjeksiyon

1. Olu┼čturucu tabanl─▒ ba─č─▒ml─▒l─▒k enjeksiyonu:

Yap─▒c─▒ tabanl─▒ DI, konteyner her biri di─čer s─▒n─▒fa ba─č─▒ml─▒l─▒─č─▒ temsil eden bir tak─▒m arg├╝manlara sahip bir s─▒n─▒f kurucuyu ├ža─č─▒rd─▒─č─▒nda ger├žekle┼čtirilir.

 public class Triangle {

private String type;

public String getType(){
    return type;
 }

public Triangle(String type){   //constructor injection
    this.type=type;
 }
}
<bean id=triangle" class ="com.test.dependencyInjection.Triangle">
        <constructor-arg value="20"/>
  </bean>
 

2. Setter bazl─▒ ba─č─▒ml─▒l─▒k enjeksiyonu:

Setter bazl─▒ DI, fasulyenizi somutla┼čt─▒rmak i├žin bir ba─č─▒ms─▒z de─či┼čken yap─▒c─▒ veya ba─č─▒ms─▒z de─či┼čken statik fabrika y├Ântemini ├ža─č─▒rd─▒ktan sonra fasulyenizdeki konteyner ├ža─čr─▒ ayarlay─▒c─▒ y├Ântemleriyle ger├žekle┼čtirilir.

 public class Triangle{

 private String type;

 public String getType(){
    return type;
  }
 public void setType(String type){          //setter injection
    this.type = type;
  }
 }

<!-- setter injection -->
 <bean id="triangle" class="com.test.dependencyInjection.Triangle">
        <property name="type" value="equivialteral"/>
 

NOT: Zorunlu ba─č─▒ml─▒l─▒klar i├žin yap─▒c─▒ arg├╝manlar─▒n─▒ ve iste─če ba─čl─▒ ba─č─▒ml─▒l─▒klar i├žin ayarlay─▒c─▒lar─▒ kullanmak iyi bir kurald─▒r. Bir ayarlay─▒c─▒da @ ─░stenilen ek a├ž─▒klamadan daha fazla bir a├ž─▒klama kullan─▒yorsak, ayarlay─▒c─▒lar─▒ gerekli ba─č─▒ml─▒l─▒klar yapmak i├žin kullanabilece─čimizi unutmay─▒n.


17







Akl─▒ma gelen en iyi benzetme, cerrah─▒n as─▒l ki┼či oldu─ču bir ameliyathanedeki cerrah ve asistan─▒ / asanlar─▒, ihtiya├ž duydu─ču zaman cerrah─▒n konsantre olabilece─či ┼čekilde ├že┼čitli cerrahi bile┼čenleri sa─člayan asistan─▒d─▒r. Yapt─▒─č─▒ en iyi ┼čey (ameliyat). Asistan olmadan, cerrah her ihtiyac─▒ oldu─čunda bile┼čenleri kendisi almak zorundad─▒r.

K─▒saca DI, ona ba─čl─▒ bile┼čenleri sa─člayarak, ba─č─▒ml─▒ bile┼čenleri almak i├žin bile┼čenler ├╝zerindeki ortak bir ek sorumlulu─ču (y├╝k) ortadan kald─▒rmak i├žin kullan─▒lan bir tekniktir.

DI, sizi gibi Tek Sorumluluk (SR) ilkesine yakla┼čt─▒r─▒r surgeon who can concentrate on surgery .

DI ne zaman kullan─▒l─▒r: DI'yi hemen hemen t├╝m ├╝retim projelerinde (k├╝├ž├╝k / b├╝y├╝k), ├Âzellikle de s├╝rekli de─či┼čen i┼č ortamlar─▒nda kullanman─▒z─▒ tavsiye ederim :)

Neden: ├ç├╝nk├╝, kodunuzun kolayca test edilebilir, tak─▒labilir vb. Olmas─▒n─▒ istersiniz, b├Âylece de─či┼čikliklerinizi h─▒zl─▒ bir ┼čekilde test edebilir ve piyasaya s├╝rebilirsiniz. Ayr─▒ca neden daha fazla kontrole sahip oldu─čunuz bir kod temeli yolculu─čunuzda sizi destekleyecek harika ├╝cretsiz ara├žlar / ├žer├ževeler varken olmas─▒n?


15







├ľrnek, 2 s─▒n─▒f Client ve var Service . Client kullanacak Service

 public class Service {
    public void doSomeThingInService() {
        // ...
    }
}
 

Ba─č─▒ml─▒l─▒k Enjeksiyonu Olmadan

Yol 1)

 public class Client {
    public void doSomeThingInClient() {
        Service service = new Service();
        service.doSomeThingInService();
    }
}
 

Yol 2)

 public class Client {
    Service service = new Service();
    public void doSomeThingInClient() {
        service.doSomeThingInService();
    }
}
 

Yol 3)

 public class Client {
    Service service;
    public Client() {
        service = new Service();
    }
    public void doSomeThingInClient() {
        service.doSomeThingInService();
    }
}
 

1) 2) 3) Kullan─▒m─▒

 Client client = new Client();
client.doSomeThingInService();
 

Avantajlar─▒

  • Basit

Dezavantajlar─▒

  • Test Client s─▒n─▒f─▒ i├žin zor
  • Yap─▒c─▒y─▒ de─či┼čtirdi─čimizde Service , her yerde Service nesne yaratma kodunu de─či┼čtirmemiz gerekir

Ba─č─▒ml─▒l─▒k Enjeksiyonu Kullan

Yol 1) Yap─▒c─▒ enjeksiyon

 public class Client {
    Service service;

    Client(Service service) {
        this.service = service;
    }

    // Example Client has 2 dependency 
    // Client(Service service, IDatabas database) {
    //    this.service = service;
    //    this.database = database;
    // }

    public void doSomeThingInClient() {
        service.doSomeThingInService();
    }
}
 

kullanma

 Client client = new Client(new Service());
// Client client = new Client(new Service(), new SqliteDatabase());
client.doSomeThingInClient();
 

Yol 2) Setter enjeksiyonu

 public class Client {
    Service service;

    public void setService(Service service) {
        this.service = service;
    }

    public void doSomeThingInClient() {
        service.doSomeThingInService();
    }
}
 

kullanma

 Client client = new Client();
client.setService(new Service());
client.doSomeThingInClient();
 

Yol 3) Aray├╝z enjeksiyonu

Https://en.wikipedia.org/wiki/Dependency_injection adresini kontrol edin.

===

┼×imdi, bu kod zaten takip edilmi┼čtir Dependency Injection ve test Client s─▒n─▒f─▒ i├žin daha kolayd─▒r .
Ancak, yine de new Service() ├žok zaman kullan─▒yoruz ve yap─▒c─▒y─▒ de─či┼čtirdi─činde bu iyi de─čil Service . Bunu ├Ânlemek i├žin,
1 gibi DI enjekt├Âr├╝n├╝ kullanabiliriz. Basit kullan─▒m k─▒lavuzu. Injector

 public class Injector {
    public static Service provideService(){
        return new Service();
    }

    public static IDatabase provideDatatBase(){
        return new SqliteDatabase();
    }
    public static ObjectA provideObjectA(){
        return new ObjectA(provideService(...));
    }
}
 

kullanma

 Service service = Injector.provideService();
 

2) K├╝t├╝phane kullan─▒n: Android i├žin

Avantajlar─▒

  • Testi kolayla┼čt─▒r─▒n
  • De─či┼čtirdi─činizde, Service sadece Enjekt├Âr s─▒n─▒f─▒nda de─či┼čtirmelisiniz.
  • E─čer kullan─▒m─▒n─▒ kullan─▒rsan─▒z Constructor Injection size yap─▒c─▒s─▒ bakt─▒─č─▒n─▒zda, Client , sen ka├ž ba─č─▒ml─▒l─▒─č─▒n─▒ g├Âreceksiniz Client s─▒n─▒fta

Dezavantajlar─▒

  • E─čer kullan─▒m─▒n─▒ kullan─▒rsan─▒z Constructor Injection , Service nesne olu┼čturulan Client olu┼čturulan, bazen biz i┼člevi kullanmak Client kullanmadan s─▒n─▒f─▒n Service b├Âylece yarat─▒lm─▒┼č Service bo┼ča

Ba─č─▒ml─▒l─▒k Enjeksiyonu tan─▒m─▒

https://en.wikipedia.org/wiki/Dependency_injection

Ba─č─▒ml─▒l─▒k kullan─▒labilecek bir nesnedir ( Service )
Enjeksiyon, bir ba─č─▒ml─▒l─▒─č─▒n ( Service ) Client onu kullanacak ba─č─▒ml─▒ bir nesneye ( ) ge├žirilmesidir.


14







Bu, nesnelerin yaln─▒zca i┼člerini yapmak i├žin gereken kadar ba─č─▒ml─▒l─▒─ča sahip olmas─▒ ve ba─č─▒ml─▒l─▒klar─▒n az olmas─▒ gerekti─či anlam─▒na gelir. Ayr─▒ca, bir nesnenin ba─č─▒ml─▒l─▒klar─▒ m├╝mk├╝n oldu─čunda ÔÇťsomutÔÇŁ nesneler ├╝zerinde de─čil, aray├╝zler ├╝zerinde olmal─▒d─▒r. (Somut bir nesne, yeni anahtar kelimeyle olu┼čturulan herhangi bir nesnedir.) Gev┼ček ba─člant─▒, daha fazla yeniden kullan─▒labilirlik, daha kolay bak─▒m kolayl─▒─č─▒ sa─člar ve pahal─▒ hizmetler yerine kolayca ÔÇťsahteÔÇŁ nesneler sa─člaman─▒za olanak tan─▒r.

ÔÇťBa─č─▒ml─▒l─▒k EnjeksiyonuÔÇŁ (DI) ÔÇťKontrol├╝n Ters ├çevirilmesiÔÇŁ (IoC) olarak da bilinir, bu gev┼ček e┼čle┼čmeyi te┼čvik etmek i├žin bir teknik olarak kullan─▒labilir.

DI'yi uygulamak i├žin iki temel yakla┼č─▒m vard─▒r:

  1. Yap─▒c─▒ enjeksiyon
  2. Ayarlay─▒c─▒ enjeksiyon

Yap─▒c─▒ enjeksiyon

Nesnelerin ba─č─▒ml─▒l─▒klar─▒n─▒ kurucuya ge├žirme tekni─čidir.

Yap─▒c─▒n─▒n bir nesneyi kabul etti─čini ve somut bir nesneyi kabul etmedi─čini unutmay─▒n. Ayr─▒ca orderDao parametresi bo┼čsa bir istisna at─▒ld─▒─č─▒n─▒ unutmay─▒n. Bu, ge├žerli bir ba─č─▒ml─▒l─▒k alman─▒n ├Ânemini vurgulamaktad─▒r. Yap─▒c─▒ Enjeksiyon, bence, bir nesneye ba─č─▒ml─▒l─▒klar─▒n─▒ vermek i├žin tercih edilen mekanizmad─▒r. Nesneyi ├ža─č─▒r─▒rken geli┼čtiriciye, hangi uygulamalar─▒n uygun bir ┼čekilde y├╝r├╝t├╝lmesi i├žin ÔÇťKi┼čiÔÇŁ nesnesine verilmesi gerekti─či a├ž─▒kt─▒r.

Ayarlay─▒c─▒ Enjeksiyon

Ancak a┼ča─č─▒daki ├Ârne─či g├Âz ├Ân├╝nde bulundurunÔÇŽ Diyelim ki on metodu ba─č─▒ml─▒ olmayan bir s─▒n─▒f─▒n─▒z var, ama IDAO'ya ba─č─▒ml─▒ olan yeni bir y├Ântem ekliyorsunuz. Yap─▒c─▒ Enjeksiyonunu kullanmak i├žin yap─▒c─▒y─▒ de─či┼čtirebilirsiniz, ancak bu sizi her yerdeki t├╝m yap─▒c─▒ ├ža─čr─▒lar─▒nda de─či┼čiklik yapmaya zorlayabilir. Alternatif olarak, ba─č─▒ml─▒l─▒─č─▒ alan yeni bir kurucu ekleyebilirsiniz, ancak bir geli┼čtirici bir kurucuyu di─čerine ne zaman kullanaca─č─▒n─▒ kolayca bilir. Son olarak, e─čer ba─č─▒ml─▒l─▒k yaratmas─▒ ├žok pahal─▒ ise, neden nadiren kullan─▒labiliyorsa, yarat─▒c─▒ya neden yarat─▒lmal─▒ ve aktar─▒lmal─▒d─▒r? ÔÇťSetter EnjeksiyonuÔÇŁ, bu gibi durumlarda kullan─▒labilecek bir ba┼čka DI tekni─čidir.

Setter Enjeksiyonu, ba─č─▒ml─▒lar─▒ kurucuya iletilmeye zorlamaz. Bunun yerine, ba─č─▒ml─▒l─▒klar ihtiya├ž duyulan nesnenin maruz kald─▒─č─▒ kamu mallar─▒na ayarlan─▒r. Daha ├Ânce de belirtildi─či gibi, bunu yapmak i├žin temel motivasyon ┼čunlar─▒ i├žerir:

  1. Eski bir s─▒n─▒f─▒n kurucusunu de─či┼čtirmek zorunda kalmadan ba─č─▒ml─▒l─▒k enjeksiyonunu desteklemek.
  2. Pahal─▒ kaynaklar─▒n veya hizmetlerin m├╝mk├╝n oldu─ču kadar ge├ž ve yaln─▒zca gerekti─činde olu┼čturulmas─▒na izin vermek.

Yukar─▒daki kodun nas─▒l g├Âr├╝nd├╝─č├╝ne bir ├Ârnek:

 public class Person {
    public Person() {}

    public IDAO Address {
        set { addressdao = value; }
        get {
            if (addressdao == null)
              throw new MemberAccessException("addressdao" +
                             " has not been initialized");
            return addressdao;
        }
    }

    public Address GetAddress() {
       // ... code that uses the addressdao object
       // to fetch address details from the datasource ...
    }

    // Should not be called directly;
    // use the public property instead
    private IDAO addressdao;
 

13







San─▒r─▒m herkes DI i├žin yazd─▒─č─▒ndan, birka├ž soru soray─▒m.

  1. Bir DI konfig├╝rasyonuna sahip oldu─čunuzda, bir s─▒n─▒fa enjekte edilecek t├╝m ger├žek uygulamalar─▒ (aray├╝zler de─čil) (├Ârne─čin bir kontrol cihaz─▒na servisler i├žin) enjekte edilecek olan bu neden bir t├╝r kodlama de─čil?
  2. ├çal─▒┼čma zaman─▒nda nesneyi de─či┼čtirmek istersem ne olur? ├ľrne─čin, benim config zaten MyController'─▒ ba┼člatt─▒─č─▒mda, FileLogger'─▒ ILogger olarak enjekte etti─čimi s├Âyl├╝yor. Ancak DatabaseLogger'─▒ enjekte etmek isteyebilirim.
  3. AClass'─▒m─▒n ihtiya├ž duydu─ču nesneleri de─či┼čtirmek istedi─čimde, ┼čimdi iki yere bakmam gerekiyor - s─▒n─▒f─▒n kendisi ve yap─▒land─▒rma dosyas─▒. Bu hayat─▒ nas─▒l kolayla┼čt─▒r─▒yor?
  4. AClass'in Aproperty'si enjekte edilmezse, bununla alay etmek daha m─▒ zor?
  5. ─░lk soruya geri d├Ânece─čim. Yeni object () kullanmak k├Ât├╝yse, aray├╝z├╝ nas─▒l uygular─▒z? Bence bir├žo─čunuz asl─▒nda aray├╝z├╝ enjekte etti─čimizi s├Âyl├╝yorsunuz, ancak konfig├╝rasyon bu aray├╝z├╝n uygulanmas─▒n─▒ belirtmenizi sa─člar .. ├žal─▒┼čma zaman─▒nda de─čil .. derleme s├╝resi boyunca kodlanm─▒┼čt─▒r.

Bu yay─▒nlanan @Adam N cevab─▒ dayanmaktad─▒r.

Neden PersonService'in GroupMembershipService i├žin endi┼čelenmesine gerek yok? Az ├Ânce bahsetti─činiz GroupMembership'in ba─čl─▒ oldu─ču birden fazla ┼čey (nesne / ├Âzellik) var. PService'de GMService gerekli olsayd─▒, bir ├Âzellik olarak sahip olurdu. Enjekte edip etmedi─činize bak─▒lmaks─▒z─▒n bununla alay edebilirsiniz. Enjekte edilmesini istedi─čim tek zaman, GMService'in ├žal─▒┼čma zaman─▒na kadar bilemeyece─činiz daha spesifik alt s─▒n─▒flar─▒ olup olmad─▒─č─▒yd─▒. O zaman alt s─▒n─▒f─▒ enjekte etmek istersiniz. Veya bunu singleton veya prototip olarak kullanmak istiyorsan─▒z. D├╝r├╝st olmak gerekirse, yap─▒land─▒rma dosyas─▒, derleme s├╝resi boyunca enjekte edilecek bir t├╝r (arabirim) i├žin hangi alt s─▒n─▒fa kadar kodlanm─▒┼č her ┼čeye sahiptir.

D├ťZENLE

Jose Maria Arranz taraf─▒ndan DI ├╝zerine g├╝zel bir yorum

DI, ba─č─▒ml─▒l─▒k y├Ân├╝n├╝ belirleme ihtiyac─▒n─▒ ortadan kald─▒rarak ve herhangi bir yap─▒┼čt─▒r─▒c─▒ kodu yazarak uyumu artt─▒r─▒r.

Yanl─▒┼č. Ba─č─▒ml─▒l─▒klar─▒n y├Ân├╝ XML bi├žiminde veya ek a├ž─▒klamalar ┼čeklindedir, ba─č─▒ml─▒l─▒klar─▒n─▒z XML kodu ve ek a├ž─▒klamalar ┼čeklinde yaz─▒lm─▒┼čt─▒r. XML ve ek a├ž─▒klamalar ARE kaynak kodu.

DI, t├╝m bile┼čenlerinizi mod├╝ler hale getirerek (yani de─či┼čtirilebilir) ve birbirlerine iyi tan─▒mlanm─▒┼č aray├╝zlere sahip olarak ba─člant─▒y─▒ azalt─▒r.

Yanl─▒┼č. Aray├╝zlere dayal─▒ mod├╝ler bir kod olu┼čturmak i├žin bir DI ├žer├ževesine ihtiyac─▒n─▒z yoktur.

De─či┼čtirilebilirlik hakk─▒nda: ├žok basit bir .properties ar┼čivi ve Class.forName ile hangi s─▒n─▒flar─▒n de─či┼čtirebilece─čini tan─▒mlayabilirsiniz. Kodunuzun HERHANG─░ bir s─▒n─▒f─▒ de─či┼čtirilebiliyorsa, Java sizin i├žin de─čildir, bir komut dosyas─▒ dili kullan─▒n. Bu arada: ek a├ž─▒klamalar yeniden derlenmeden de─či┼čtirilemez.

Bence DI ├žer├ževelerinin tek bir nedeni var: kazan plakas─▒ azalmas─▒. ─░yi yap─▒lm─▒┼č bir fabrika sistemiyle, tercih etti─činiz DI ├žer├ževesiyle ayn─▒, daha kontroll├╝ ve daha ├Âng├Âr├╝lebilir olan─▒ yapabilirsiniz, DI ├žer├ževeleri kod azaltma s├Âz├╝ verir (XML ve ek a├ž─▒klamalar da kaynak koddur). Sorun ┼ču ki, bu kazan plakas─▒ azaltma, ├žok basit durumlarda (s─▒n─▒f ba┼č─▒na bir ├Ârnek ve benzeri) sadece ger├žektir, bazen ger├žek d├╝nyada, uygun servis nesnesini se├žmek, bir s─▒n─▒f─▒ bir singleton nesnesine e┼člemek kadar kolay de─čildir.


10







Ba─č─▒ml─▒l─▒k Enjeksiyonu , kodun bir k─▒sm─▒ i├žin (├Ârne─čin bir s─▒n─▒f) ba─č─▒ml─▒l─▒klara (kodun di─čer k─▒s─▒mlar─▒, ├Ârne─čin, di─čer s─▒n─▒flar, buna ba─čl─▒ olarak) mod├╝ler bir ┼čekilde kodlanm─▒┼č olmadan (yani, buna ba─čl─▒ olarak) eri┼čmenin bir yolu (asl─▒nda herhangi bir ┼čekilde ) anlam─▒na gelir . gerekti─činde serbest├že de─či┼čebilir, ge├žersiz k─▒l─▒nabilir, hatta ba┼čka bir zamanda y├╝klenebilirler)

(ve ps, evet olduk├ža basit bir konsept i├žin a┼č─▒r─▒ keskin 25 $ bir isim haline geldi) , .25 sent


8







Zaten bir├žok cevap oldu─čunu biliyorum, ancak bunu ├žok faydal─▒ buldum: http://tutorials.jenkov.com/dependency-injection/index.html

Ba─č─▒ml─▒l─▒k Yok:

 public class MyDao {

  protected DataSource dataSource =
    new DataSourceImpl("driver", "url", "user", "password");

  //data access methods...
  public Person readPerson(int primaryKey) {...}

}
 

Ba─č─▒ml─▒l─▒k:

 public class MyDao {

  protected DataSource dataSource = null;

  public MyDao(String driver, String url, String user, String
 password){
    this.dataSource = new DataSourceImpl(driver, url, user, password);
  }

  //data access methods...
  public Person readPerson(int primaryKey)
  {...}

}
 

Ba┼člatman─▒n bir kurucuya nas─▒l DataSourceImpl ta┼č─▒nd─▒─č─▒na dikkat edin . Yap─▒c─▒, gereken d├Ârt de─čer olan d├Ârt parametreyi al─▒r DataSourceImpl . MyDao S─▒n─▒f hala bu d├Ârt de─čere ba─čl─▒ olsa da , art─▒k bu ba─č─▒ml─▒l─▒klar─▒n kendisini kar┼č─▒lam─▒yor. MyDao ├ľrnek olu┼čturan her s─▒n─▒f taraf─▒ndan sa─član─▒r .


7







Pop├╝ler cevaplar yarars─▒zd─▒r, ├ž├╝nk├╝ ba─č─▒ml─▒l─▒k enjeksiyonunu yararl─▒ olmayan bir ┼čekilde tan─▒mlarlar. "Ba─č─▒ml─▒l─▒k" ile, X nesnesinin ihtiya├ž duydu─ču ├Ânceden var olan ba┼čka bir nesneyi kastetti─čimizi kabul edelim. Ama biz s├Âyledi─čimizde "ba─č─▒ml─▒l─▒k enjeksiyonu" yapt─▒─č─▒m─▒z─▒ s├Âylemiyoruz.

 $foo = Foo->new($bar);
 

Biz sadece bu parametrelere yap─▒c─▒ diyoruz. Yap─▒c─▒lar icat edildi─činden beri bunu d├╝zenli olarak yap─▒yoruz.

"Ba─č─▒ml─▒l─▒k enjeksiyonu", bir t├╝r "kontrol├╝n tersine ├ževrilmesi" olarak kabul edilir; bu, bir mant─▒─č─▒n arayandan ├ž─▒kar─▒ld─▒─č─▒ anlam─▒na gelir. Arayan ki┼či parametrelerden ge├žti─činde durum b├Âyle de─čil, bu y├╝zden DI ise, DI kontrol├╝n tersine ├ževrilmesi anlam─▒na gelmez.

DI, arayan ve ba─č─▒ml─▒l─▒klar─▒ y├Âneten yap─▒c─▒ aras─▒nda bir orta seviye oldu─ču anlam─▒na gelir. Makefile, ba─č─▒ml─▒l─▒k enjeksiyonunun basit bir ├Ârne─čidir. "Arayan", komut sat─▒r─▒na "make bar" yazan ki┼či ve "constructor", derleyicidir. Makefile, ├žubu─čun foo'ya ba─čl─▒ oldu─čunu belirtir ve

 gcc -c foo.cpp; gcc -c bar.cpp
 

yapmadan ├Ânce

 gcc foo.o bar.o -o bar
 

"Make bar" yazan ki┼činin, bar─▒n foo'ya ba─čl─▒ oldu─čunu bilmesi gerekmez. Ba─č─▒ml─▒l─▒k "make bar" ve gcc aras─▒na enjekte edildi.

Orta seviyenin temel amac─▒, sadece yap─▒c─▒ya ba─č─▒ml─▒l─▒klar─▒ iletmek de─čil, t├╝m ba─č─▒ml─▒l─▒klar─▒ tek bir yerde listelemek ve onlar─▒ kodlay─▒c─▒dan gizlemektir (kodlay─▒c─▒y─▒ sa─člamak i├žin de─čil).

Genellikle ara seviye, istenen her nesne tipinin yerine getirmesi gereken bir rol sa─člamas─▒ gereken in┼ča edilmi┼č nesneler i├žin fabrikalar sa─člar. Bunun nedeni, in┼čaat─▒n ayr─▒nt─▒lar─▒n─▒ gizleyen bir ara seviyeye sahip olman─▒z, zaten fabrikalar─▒n dayatt─▒─č─▒ soyutlama cezalar─▒n─▒ zaten ├╝stlendi─činizden dolay─▒, fabrikalar─▒ da kullanabilirsiniz.


7







Ba─č─▒ml─▒l─▒k enjeksiyonu, genellikle "Ba─č─▒ml─▒l─▒k Gizlili─či" ┼čart─▒ olarak adland─▒r─▒labilecek bir ├ž├Âz├╝md├╝r. Ba─č─▒ml─▒l─▒k Yasaklama, ÔÇťa├ž─▒kÔÇŁ bir niteli─či, onu gerektiren bir s─▒n─▒fa ba─č─▒ml─▒l─▒k sa─člama s├╝recinden ├ž─▒karmak ve bu nedenle bir ┼čekilde s├Âz├╝ ge├žen s─▒n─▒fa ba─č─▒ml─▒l─▒─č─▒n sa─članmas─▒n─▒ engellemek i├žin kullan─▒lan bir y├Ântemdir. Bu mutlaka k├Ât├╝ bir ┼čey de─čil. Asl─▒nda, bir s─▒n─▒fa ba─č─▒ml─▒l─▒─č─▒n nas─▒l sa─čland─▒─č─▒n─▒n gizlenmesiyle s─▒n─▒f─▒n d─▒┼č─▒nda bir ┼čey ba─č─▒ml─▒l─▒─č─▒n yarat─▒lmas─▒ndan sorumludur; bu, ├že┼čitli senaryolarda, herhangi bir de─či┼čiklik yapmadan s─▒n─▒fa farkl─▒ bir ba─č─▒ml─▒l─▒k uygulamas─▒ sa─članabilece─či anlam─▒na gelir. s─▒n─▒fa. Bu, ├╝retim ve test modlar─▒ aras─▒nda ge├ži┼č yapmak i├žin m├╝kemmeldir (├Ârne─čin, 'sahte' bir hizmet ba─č─▒ml─▒l─▒─č─▒ kullanarak).

Ne yaz─▒k ki, k├Ât├╝ olan k─▒s─▒m, baz─▒ insanlar─▒n ba─č─▒ml─▒l─▒k ┼ča┼č─▒rtmak i├žin ├Âzel bir ├žer├ževeye ihtiya├ž duydu─čunu ve bunu yapmak i├žin belirli bir ├žer├ževeyi kullanmamay─▒ se├žerseniz bir ┼čekilde 'daha az' bir programc─▒ oldu─čunuzu varsaymalar─▒d─▒r. Bir├žo─čunun inand─▒─č─▒, son derece rahats─▒z edici bir efsane, ba─č─▒ml─▒l─▒k enjeksiyonunun ba─č─▒ml─▒l─▒k ┼ča┼č─▒rtman─▒n tek yolu oldu─ču y├Ân├╝ndedir. Bu kan─▒tlanabilir ve tarihsel ve a├ž─▒k bir ┼čekilde% 100 yanl─▒┼čt─▒r, ancak baz─▒ insanlar─▒ ba─č─▒ml─▒l─▒k ┼ča┼č─▒rtma gereksinimleriniz i├žin ba─č─▒ml─▒l─▒k enjeksiyonuna alternatifler oldu─čuna ikna etmekte zorlanacaks─▒n─▒z.

Programc─▒lar y─▒llarca ba─č─▒ml─▒l─▒k gizleme gereksinimini anlam─▒┼č ve ba─č─▒ml─▒l─▒k enjeksiyonunun tasarlanmas─▒ndan ├Ânce ve sonra bir├žok alternatif ├ž├Âz├╝m geli┼čti. Fabrika desenleri vard─▒r ancak belirli bir ├Ârne─čine hi├ž enjeksiyon gereklidir ThreadLocal kullanarak bir├žok se├ženek de vard─▒r - ba─č─▒ml─▒l─▒k etkili bir kar┼č─▒ (kolayl─▒k statik al─▒c─▒ y├Ântemlerle) nesne kullan─▒labilir hale yarar─▒ vard─▒r iplik i├žine enjekte edilir herhangi s─▒n─▒ftan oldu─čunu bunu gerektiren s─▒n─▒flara ek a├ž─▒klamalar eklemek zorunda kalmadan ve bunu ger├žekle┼čtirmek i├žin karma┼č─▒k XML 'tutkal─▒' kurmay─▒ gerektirir. Ba─č─▒ml─▒l─▒klar─▒n─▒z s├╝reklilik i├žin gerekli oldu─čunda (JPA / JDO veya her neyse), ÔÇťkal─▒c─▒ s├╝reklili─čiÔÇŁ ├žok daha kolay bir ┼čekilde elde etmenize olanak tan─▒r ve yaln─▒zca POJO'lardan olu┼čan etki alan─▒ modeli ve i┼č modeli s─▒n─▒flar─▒ ile (yani, hi├žbir ├žer├ževeye ├Âzel / kilitli de─čil).


6







Kitaptan, ─░yi Yerle┼čik Java Geli┼čtiricisi: Java 7'nin hayati teknikleri ve polyglot programlama

DI, ba─č─▒ml─▒l─▒klar─▒n─▒z─▒ bulma s├╝recinin ┼ču anda y├╝r├╝rl├╝kteki kodunuzun do─črudan kontrol├╝ d─▒┼č─▒nda oldu─ču belirli bir IoC ┼čeklidir.


5







Kitap adl─▒ Apress.Spring.Persistence.with.Hibernate.Oct.2010

Ba─č─▒ml─▒l─▒k enjeksiyonunun amac─▒, harici yaz─▒l─▒m bile┼čenlerini uygulama i┼č mant─▒─č─▒n─▒zdan ├ž├Âzme ├žal─▒┼čmalar─▒n─▒ ay─▒rmakt─▒r. Ba─č─▒ml─▒l─▒k enjeksiyonu olmadan, bir bile┼čenin gereken hizmetlere nas─▒l eri┼čti─činin ayr─▒nt─▒lar─▒, bile┼čenin koduyla kar─▒┼čt─▒r─▒labilir. Bu sadece hata potansiyelini artt─▒rmaz, kod ┼či┼čirmesi ekler ve bak─▒m karma┼č─▒kl─▒klar─▒n─▒ b├╝y├╝t├╝r; Bile┼čenleri birbirine daha yak─▒n ba─člar, yeniden yap─▒lanma veya test s─▒ras─▒nda ba─č─▒ml─▒l─▒klar─▒ de─či┼čtirmeyi zorla┼čt─▒r─▒r.


4







Ba─č─▒ml─▒l─▒k Enjeksiyonu (DI), OOP'un temel ├Âzelli─čini kullanan Tasar─▒m Birimlerinden biridir - bir nesnede ba┼čka bir nesneyle olan ili┼čki. Kal─▒t─▒m, bir nesneyi daha karma┼č─▒k ve spesifik ba┼čka bir nesne yapmak i├žin miras al─▒rken, ili┼čki veya ili┼čki, niteli─či kullanarak bir nesneden ba┼čka bir nesneye bir i┼čaret├ži olu┼čturur. DI'nin g├╝c├╝, aray├╝zler ve gizleme kodu gibi OOP'un di─čer ├Âzellikleri ile birliktedir. Diyelim ki, basitlik i├žin sadece bir kitap ├Âd├╝n├ž alabilen k├╝t├╝phanede bir m├╝┼čterimiz (abone) var.

Kitab─▒n Aray├╝z├╝:

 package com.deepam.hidden;

public interface BookInterface {

public BookInterface setHeight(int height);
public BookInterface setPages(int pages);   
public int getHeight();
public int getPages();  

public String toString();
}
 

Daha sonra bir├žok kitap alabiliriz; t├╝rlerinden biri kurgu:

 package com.deepam.hidden;

public class FictionBook implements BookInterface {
int height = 0; // height in cm
int pages = 0; // number of pages

/** constructor */
public FictionBook() {
    // TODO Auto-generated constructor stub
}

@Override
public FictionBook setHeight(int height) {
  this.height = height;
  return this;
}

@Override
public FictionBook setPages(int pages) {
  this.pages = pages;
  return this;      
}

@Override
public int getHeight() {
    // TODO Auto-generated method stub
    return height;
}

@Override
public int getPages() {
    // TODO Auto-generated method stub
    return pages;
}

@Override
public String toString(){
    return ("height: " + height + ", " + "pages: " + pages);
}
}
 

Art─▒k abone kitabla ili┼čki kurabilir:

 package com.deepam.hidden;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class Subscriber {
BookInterface book;

/** constructor*/
public Subscriber() {
    // TODO Auto-generated constructor stub
}

// injection I
public void setBook(BookInterface book) {
    this.book = book;
}

// injection II
public BookInterface setBook(String bookName) {
    try {
        Class<?> cl = Class.forName(bookName);
        Constructor<?> constructor = cl.getConstructor(); // use it for parameters in constructor
        BookInterface book = (BookInterface) constructor.newInstance();
        //book = (BookInterface) Class.forName(bookName).newInstance();
    } catch (InstantiationException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    } catch (SecurityException e) {
        e.printStackTrace();
    } catch (IllegalArgumentException e) {
        e.printStackTrace();
    } catch (InvocationTargetException e) {
        e.printStackTrace();
    }
    return book;
}

public BookInterface getBook() {
  return book;
}

public static void main(String[] args) {

}

}
 

Her ├╝├ž s─▒n─▒f da kendi uygulamas─▒ i├žin gizlenebilir. ┼×imdi bu kodu DI i├žin kullanabiliriz:

 package com.deepam.implement;

import com.deepam.hidden.Subscriber;
import com.deepam.hidden.FictionBook;

public class CallHiddenImplBook {

public CallHiddenImplBook() {
    // TODO Auto-generated constructor stub
}

public void doIt() {
    Subscriber ab = new Subscriber();

    // injection I
    FictionBook bookI = new FictionBook();
    bookI.setHeight(30); // cm
    bookI.setPages(250);
    ab.setBook(bookI); // inject
    System.out.println("injection I " + ab.getBook().toString());

    // injection II
    FictionBook bookII = ((FictionBook) ab.setBook("com.deepam.hidden.FictionBook")).setHeight(5).setPages(108); // inject and set
    System.out.println("injection II " + ab.getBook().toString());      
}

public static void main(String[] args) {
    CallHiddenImplBook kh = new CallHiddenImplBook();
    kh.doIt();
}
}
 

Ba─č─▒ml─▒l─▒k enjeksiyonunu kullanman─▒n bir├žok farkl─▒ yolu vard─▒r. Bunu Singleton, vb. ─░le birle┼čtirmek m├╝mk├╝nd├╝r, ancak yine de temelde, sadece ba┼čka bir nesnenin i├žindeki nesne t├╝r├╝n├╝n niteli─či yarat─▒larak yap─▒lan ili┼čkilendirmedir. Yararl─▒l─▒k sadece ve sadece ├Âzelliktedir, tekrar tekrar yazmam─▒z gereken bu kod her zaman haz─▒rlan─▒r ve bizim i├žin yap─▒l─▒r. Bu nedenle DI'nin, Inversion of Control (IoC) ile bu kadar yak─▒ndan ba─članmas─▒, yani program─▒m─▒z─▒n kontrol├╝m├╝ze ge├žmesi anlam─▒na gelir, bu da kodumuza fasulye enjekte eden ba┼čka bir ├žal─▒┼čan mod├╝l├╝ kontrol eder. (Enjekte edilebilen her nesne bir Fasulye olarak imzalanabilir veya imzalanabilir.) ├ľrne─čin, ilkbaharda bu bizim i├žin ├žal─▒┼čan ApplicationContext kab─▒ olu┼čturularak ve ba┼člat─▒larak yap─▒l─▒r . Biz sadece kodumuzda ─░├žeri─či yarat─▒r ve fasulyeyi ba┼člatmay─▒ ├ža─č─▒r─▒r─▒z. O anda enjeksiyon otomatik olarak yap─▒lm─▒┼čt─▒r.


4







Basit bir ifadeyle, ba─č─▒ml─▒l─▒k enjeksiyonu (DI), ba─č─▒ml─▒l─▒klar─▒ ortadan kald─▒rman─▒n veya farkl─▒ nesneler aras─▒ndaki s─▒k─▒ kaplin yoludur. Ba─č─▒ml─▒l─▒k Enjeksiyonu, her bir nesneye yap─▒┼čkan bir davran─▒┼č verir.

DI, "Bizi arama, seni arayaca─č─▒z" diyen IOC bahar m├╝d├╝r├╝n├╝n uygulamas─▒. Ba─č─▒ml─▒l─▒k enjeksiyon programlay─▒c─▒s─▒n─▒n kullan─▒lmas─▒, yeni anahtar s├Âzc├╝─č├╝ kullanarak nesne olu┼čturman─▒za gerek yoktur.

Nesneler bir kez Spring kapsay─▒c─▒s─▒na y├╝klenir ve daha sonra bu nesneleri Spring kapsay─▒c─▒s─▒ndan getBean (String beanName) y├Ântemini kullanarak almak istedi─čimizde yeniden kullan─▒r─▒z.


3







Ba─č─▒ml─▒l─▒k enjeksiyonu, Spring Framework ile ilgili kavram─▒n kalbidir. Herhangi bir proje yay─▒n─▒n ├žer├ževesini olu┼čtururken hayati bir rol oynayabilir ve burada ba─č─▒ml─▒l─▒k enjeksiyonu s├╝rahiye gelir.

Asl─▒nda, Java'da A s─▒n─▒f─▒ ve B s─▒n─▒f─▒ olarak iki farkl─▒ s─▒n─▒f olu┼čturdu─čunuzu ve B s─▒n─▒f─▒ i├žin hangi fonksiyonun mevcut oldu─čunu, A s─▒n─▒f─▒nda kullanmak istedi─činizden, yani o zaman ba─č─▒ml─▒l─▒k enjeksiyonunun kullan─▒labilece─čini varsayal─▒m. Bir s─▒n─▒f─▒n nesnesini di─čerinden ay─▒rabilece─činiz yerde, ayn─▒ ┼čekilde ba┼čka bir s─▒n─▒ftaki b├╝t├╝n bir s─▒n─▒f─▒ eri┼čilebilir hale getirmek i├žin enjekte edebilirsiniz. Bu ┼čekilde ba─č─▒ml─▒l─▒k a┼č─▒labilir.

BA─×IMSIZLIK ENJEKS─░YONU ─░K─░ SINIFTIRMA VE AYRI TUTARAK AYNI ZAMANDA BAS─░TT─░R.


3







Ba─č─▒ml─▒l─▒k Enjeksiyonu (DI), Ba─č─▒ml─▒l─▒k ─░nversiyon Prensibi (DIP) uygulamas─▒n─▒n bir par├žas─▒d─▒r, buna da Kontrol ─░nversiyonu (IoC) ad─▒ verilir. Temel olarak DIP i┼člemine ihtiyac─▒n─▒z var ├ž├╝nk├╝ kodunuzu daha tek bir monolitik sistem yerine daha mod├╝ler ve ├╝nite test edilebilir hale getirmek istiyorsan─▒z. B├Âylece kodun s─▒n─▒ftan ayr─▒labilecek ve soyutlanabilecek k─▒s─▒mlar─▒n─▒ tan─▒mlamaya ba┼člars─▒n─▒z. ┼×imdi soyutlaman─▒n uygulanmas─▒n─▒n s─▒n─▒f d─▒┼č─▒ndan enjekte edilmesi gerekiyor. Normalde bu, yap─▒c─▒ arac─▒l─▒─č─▒yla yap─▒labilir. B├Âylece soyutlamay─▒ bir parametre olarak kabul eden bir kurucu yarat─▒yorsunuz ve buna ba─č─▒ml─▒l─▒k enjeksiyonu deniyor (yap─▒c─▒ arac─▒l─▒─č─▒yla). DIP, DI ve IoC konteyneri hakk─▒nda daha fazla a├ž─▒klama i├žin Buradan okuyabilirsinizhttp://kusnaditjung.blogspot.co.uk/2016/05/dependency-inversion-principle-dip.html


3







Ba─č─▒ml─▒l─▒k Enjeksiyonunun ne oldu─čunun, teknik ama├žlara de─čil, temel ama├žlara odaklanarak ( buradan itibaren ) temel olarak biraz farkl─▒, k─▒sa ve kesin bir tan─▒m─▒n─▒ ├Âneriyorum :

Ba─č─▒ml─▒l─▒k Enjeksiyonu, her bir hizmetin ba─č─▒ml─▒l─▒klar─▒ ile parametreledi─či statik, durumsuz, hizmet nesnelerinin grafi─čini olu┼čturma i┼člemidir.

Uygulamalar─▒m─▒zda yaratt─▒─č─▒m─▒z nesneler (Java, C # veya ba┼čka bir nesne y├Ânelimli dil kullan─▒yor olsak da) genellikle iki kategoriden birine girer: durumsuz, statik ve k├╝resel ÔÇťhizmet nesneleriÔÇŁ (mod├╝ller) ve durumlu, dinamik ve yerel ÔÇťVeri nesneleriÔÇŁ.

Mod├╝l grafi─či - servis nesnelerinin grafi─či - genellikle uygulama ba┼člang─▒c─▒nda olu┼čturulur. Bu, Spring gibi bir kap kullan─▒larak yap─▒labilir, ancak parametrelerin nesne yap─▒c─▒lar─▒na iletilmesiyle elle de yap─▒labilir. Her iki yolun da avantajlar─▒ ve dezavantajlar─▒ vard─▒r, ancak ba┼čvurunuzda DI kullanmak i├žin kesinlikle bir ├žer├ževe gerekmez.

Bir gereklilik, hizmetlerin ba─č─▒ml─▒l─▒klar─▒ taraf─▒ndan parametrelenmesi gerekti─čidir. Bunun tam olarak anlam─▒, verilen sistemde al─▒nan dile ve yakla┼č─▒ma ba─čl─▒d─▒r. Genellikle, bu yap─▒c─▒ parametreleri bi├žimini al─▒r, ancak ayarlay─▒c─▒lar─▒ kullanmak da bir se├ženektir. Bu ayn─▒ zamanda bir servisin ba─č─▒ml─▒l─▒klar─▒n─▒n, servis kullan─▒c─▒lar─▒n─▒n kullan─▒m─▒ndan gizlenen (bir servis y├Ântemi ├ža─čr─▒l─▒rken) anlam─▒na gelir.

Ne zaman kullan─▒l─▒r? Ne zaman uygulama yeterince mant─▒k, ayr─▒ mod├╝ller i├žine enkaps├╝le olan, mod├╝ller aras─▒nda bir ba─č─▒ml─▒l─▒k grafi─či ile kodun okunabilirli─či ve ke┼čfedilirli─či bir kazan├ž sa─člar s├Âyleyebilirim.


3







Christoffer Noring'den Pablo Deeleman'─▒n ÔÇťA├ž─▒sal ├ľ─črenme - ─░kinci Bas─▒mÔÇŁ adl─▒ kitab─▒:

"Uygulamalar─▒m─▒z b├╝y├╝d├╝k├že ve geli┼čtik├že, kod varl─▒klar─▒m─▒z─▒n her biri dahili olarak, yaz─▒l─▒m m├╝hendisli─či d├╝nyas─▒nda ba─č─▒ml─▒l─▒klar olarak daha iyi bilinen di─čer nesnelerin ├Ârneklerini gerektirecektir. Bu ba─č─▒ml─▒l─▒klar─▒ ba─č─▒ml─▒ m├╝┼čteriye ge├žirme eylemi enjeksiyon olarak bilinir, ve ayn─▒ zamanda enjekt├Âr olarak adland─▒r─▒lan ba┼čka bir kod kurulu┼čunun kat─▒l─▒m─▒n─▒ gerektirir: Enjekt├Âr, istenen ba─č─▒ml─▒l─▒klar─▒ somutla┼čt─▒rmak ve ba┼člatmak i├žin sorumluluk alacakt─▒r, b├Âylece m├╝┼čteriye ba┼čar─▒yla enjekte edildikleri andan itibaren kullan─▒ma haz─▒r hale gelirler. m├╝┼čteri kendi ba─č─▒ml─▒l─▒klar─▒n─▒ nas─▒l ba┼člatabilece─či hakk─▒nda hi├žbir ┼čey bilmiyor ve sadece bunlar─▒ kullanmak i├žin uygulad─▒klar─▒ aray├╝z├╝n fark─▒nda. ÔÇŁ


2



─░lgili yay─▒nlar


Ba─č─▒ml─▒l─▒k Enjeksiyonu kullanman─▒n olumsuzluklar─▒ nelerdir? [kapal─▒]

Ba─č─▒ml─▒l─▒k Enjeksiyonu ve Servis Belirleme kal─▒plar─▒ aras─▒ndaki fark nedir?

Javax.inject.Named ek a├ž─▒klamas─▒ ne i├žin kullan─▒lacak?

Ba─č─▒ml─▒l─▒k enjeksiyon kaplar─▒n─▒n faydalar─▒ nelerdir?

Bahar ├çer├ževesinde Ba─č─▒ml─▒l─▒k Enjeksiyonu ve Kontrol├╝n Tersine ├çevirilmesi Nedir?

Strateji kal─▒b─▒ ve Ba─č─▒ml─▒l─▒k Enjeksiyonu aras─▒ndaki fark nedir?

SQL enjeksiyonu nedir? [├žift]

Ba─č─▒ml─▒l─▒k Enjeksiyonu i├žin Reader Monad: ├žoklu ba─č─▒ml─▒l─▒klar, i├ž i├že aramalar

Ba─č─▒ml─▒ yazma nedir?

Ba─č─▒ml─▒l─▒k Enjeksiyonu Ba─člam─▒nda Kompozisyon K├Âk├╝ Nedir?

Etiketle ilgili di─čer sorular [design-patterns]


Mevcut, yay─▒nlanmam─▒┼č taahh├╝t mesajlar─▒ nas─▒l de─či┼čtirilir?

Java ÔÇťreferansa g├ÂreÔÇŁ veya ÔÇťde─čere g├ÂreÔÇŁ m─▒?

Metin se├žimi vurgulamas─▒ nas─▒l devre d─▒┼č─▒ b─▒rak─▒l─▒r

Python'da harici bir komut ├ža─č─▒rmak

Bir numaraland─▒rmak nas─▒l?

─░nt nas─▒l numaraland─▒rmak i├žin?

SQLite'─▒n saniyede INSERT performans─▒n─▒ artt─▒rmak?

ArrayList'in bir sat─▒rda ba┼člat─▒lmas─▒

Ruby'de bir switch ifadesi nas─▒l yaz─▒l─▒r

Ge├žerli dizini ve dosyan─▒n dizinini bulun [duplicate]