“Düşük” uygulama katmanları için “yüksek” olanların farkında olmamak neden iyi bir fikirdir?

Tipik (iyi tasarlanmış) bir MVC web uygulamasında, veritabanı model kodunun farkında değildir, model kodu denetleyici kodunun farkında değildir ve denetleyici kodu görünüm kodunun farkında değildir. (Donanımdan daha ileri bir zamanda başlayabileceğinizi ya da belki daha da ileri gideceğinizi ve kalıp aynı olabileceğini hayal ediyorum)

Diğer yöne gitmek, sadece bir katman aşağı gidebilirsiniz. Görünüm, denetleyicinin farkında olabilir, modelden değil; denetleyici modelin farkında olabilir ancak veritabanını bilmez; Model veritabanının farkında olabilir ancak işletim sistemi hakkında bilgi sahibi olamaz. (Daha derin olan her şey muhtemelen alakasızdır.)

Bunun neden iyi bir fikir olduğunu sezgisel bir şekilde anlayabiliyorum ama dile getiremiyorum. Neden bu tek yönlü katmanlama tarzı iyi bir fikir?

Katmanlar, modüller, aslında mimarlığın kendisi, bilgisayar programlarının insanlar tarafından anlaşılmasını kolaylaştıracak araçlardır . Sayısal olarak optimal bir problem çözme yöntemi, neredeyse her zaman, modüler olmayan, kendi kendine referans veren ve hatta kendi kendini değiştiren bir kod olan karışık olmayan karmaşa karmaşasıdır; seçim basıncı. Bu tür sistemler hiçbir katmana, ayırt edilebilir bir bilgi akışı yönüne, aslında ayırt edebileceğimiz bir yapıya sahip değiller. Yazarları dışındaki herkese saf sihirle çalışıyor gibi görünüyorlar.

Yazılım mühendisliğinde, bundan kaçınmak istiyoruz. İyi mimari, sistemin normal insanlar tarafından anlaşılabilir hale getirilmesi için bir miktar verimden fedakarlık etme kararıdır. Her seferinde bir şeyi anlamak, birlikte kullanıldığında anlamlı olan iki şeyi anlamaktan daha kolaydır. Bu nedenle modüller ve katmanlar iyi bir fikirdir.

Ancak kaçınılmaz olarak, modüller birbirlerinden fonksiyonlar çağırmalı ve üst üste katmanlar oluşturulmalıdır. Bu yüzden pratikte, bazı parçaların başka parçalara ihtiyaç duyması için sistemlerin kurulması her zaman gereklidir. Tercih edilen uzlaşma onları bir parçanın diğerine ihtiyaç duyduğu şekilde inşa etmektir, ancak bu parça ilk parçayı geri gerektirmez. Ve bu tam olarak tek yönlü katmanlamanın bize sağladığı şeydir: iş kurallarını bilmeden veritabanı şemasını anlamak ve kullanıcı arayüzünü bilmeden iş kurallarını anlamak mümkündür. Her iki yönde de bağımsızlığa sahip olmak güzel olurdu - birinin bir şey bilmeden yeni bir kullanıcı arayüzü programlamasına izin vermekiş kuralları hakkında hiçbir şekilde - ancak pratikte bu neredeyse hiçbir zaman mümkün değildir. “Döngüsel bağımlılık yok” veya “Bağımlılıklar sadece bir seviyeye inmelidir” gibi temel kurallar, bir anda bir şeyin iki şeyden daha kolay anlaşılmasının daha kolay olduğu temel fikrin pratikte elde edilebilir sınırını yakalamaktır.

Temel motivasyon şudur: Siz tüm katmanı söküp tamamen farklı (yeniden yazılmış) bir yerine geçebilir ve FARKLI OLMAYAN FARKLI OLMASI GEREKEN BİR OLSUN.

En belirgin örnek alt tabakayı sökmek ve farklı bir yerine geçmek. Donanımın simülasyonuna karşı üst katman (lar) geliştirdiğinizde ve ardından gerçek donanımın yerine geçtiğinizde yaptığınız şey budur.

Bir sonraki örnek bir orta katmanı söküp yerine farklı bir orta katmanı yerleştirmenizdir. RS-232 üzerinden çalışan bir protokol kullanan bir uygulamayı düşünün. Bir gün, protokolün kodlamasını tamamen değiştirmelisin çünkü "başka bir şey değişti". (Örnek: ASCII kodlarından düz ASCII kodlarından ASCII akışlarının Reed-Solomon kodlamasına geçiş, çünkü şehir merkezinde LA şehir merkezinden Marina Del Rey'e bir radyo bağlantısı üzerinde çalışıyordunuz ve şimdi şehir merkezinde LA şehir merkezinden bir prob veya yörüngeye giden bir radyo bağlantısı üzerinde çalışıyorsunuz. Jüpiter'in aylarından biri ve bu bağlantının çok daha ileri bir hata düzeltmesine ihtiyacı var.)

Bu işi yapmanın tek yolu, her bir katmanın yukarıdaki katmana bilinen ve tanımlanmış bir arabirim vermesi ve aşağıdaki katmana bilinen ve tanımlanmış bir arabirim beklemesidir.

Şimdi, tam olarak alt katların üst katlar hakkında hiçbir şey bilmediği bir durum söz konusu değil. Aksine, alt katmanın bildiği şey, hemen üzerindeki katmanın, tanımlanan arayüze göre tam olarak çalışacağıdır. Daha fazla bir şey bilemez, çünkü tanım olarak tanımlanan arayüzde olmayan herhangi bir şey, BİLDİRİM YOKTAN değişebilir.

RS-232 katmanı ASCII, Reed-Solomon, Unicode (Arapça kod sayfası, Japonca kod sayfası, Rigellian Beta kod sayfası) veya ne çalıştığını bilmiyor. Sadece bir bayt dizisi elde ettiğini ve bu baytları bir limana yazdığını biliyor. Gelecek hafta, tamamen farklı bir şeyden tamamen farklı bir bayt dizisi alıyor olabilir. Umurunda değil Sadece bayt taşır.

Katmanlı tasarımın ilk (ve en iyi) açıklaması, Dijkstra'nın “Çok Programlı Sistemin Yapısı” adlı klasik makalesidir . Bu işte okuma gereklidir.

Daha yüksek seviyeler nedeniyle olabilir değişecektir.

Bu gerçekleştiğinde, gerekliliklerin değişmesi nedeniyle, yeni kullanıcılar, farklı teknolojiler, modüler (yani tek yönlü olarak katmanlı) bir uygulama daha az bakım gerektirmeli ve yeni ihtiyaçlara daha kolay uyarlanmalıdır.

Bence asıl sebep, işleri daha sıkı bir şekilde birbirine bağlaması. Bağlantı ne kadar sıkıysa, daha sonra sorunla karşılaşması o kadar olasıdır. Bu makaleye bakın daha fazla bilgi: Eşleştirme

İşte bir alıntı:

Dezavantajları

Sıkıca bağlı sistemler, genellikle dezavantajlar olarak görülen aşağıdaki gelişim özelliklerini sergileme eğilimindedir: Bir modülde yapılan değişiklik, genellikle diğer modüllerde değişikliklerin dalgalanma etkisini zorlar. Modüllerin montajı, modüller arası bağımlılığın artması nedeniyle daha fazla çaba ve / veya zaman gerektirebilir. Bağımlı modüller dahil edilmesi gerektiğinden, belirli bir modülün yeniden kullanılması ve / veya test edilmesi zor olabilir.

Bununla birlikte, daha sıkı bir birleşik bir sisteme sahip olmanın nedeni, performans nedenlerinden ötürü söylenir. Bahsettiğim makalenin de bu konuda bazı bilgileri var.

IMO, çok basit. İçinde bulunduğu bağlamı referans alarak devam eden bir şeyi tekrar kullanamazsınız.

Katmanlar iki yönlü bağımlılığa sahip olmamalıdır

Katmanlı bir mimarinin avantajları, katmanların bağımsız olarak kullanılması gerektiğidir:

• alt katmanı değiştirmeden birincisine ek olarak farklı bir sunum katmanı oluşturabilmeniz gerekir (örneğin, mevcut bir web arayüzüne ek olarak bir API katmanı oluşturmak)
• üst katmanı değiştirmeden alt katmanı yeniden yerleştirebilir ya da sonunda değiştirebilmelisiniz

Bu koşullar temel olarak simetriktir . Sadece bir bağımlılık yönüne sahip genellikle daha iyidir, ama neden onlar açıklamak hangi .

Bağımlılık yönü komut yönünü takip etmelidir.

Yukarıdan aşağıya bağımlılık yapısını tercih etmemizin nedeni, en üst nesnelerin alt nesneleri oluşturması ve kullanmasıdır . Bağımlılık temel olarak “A, B olmadan çalışamazsa B'ye bağlıdır” anlamına gelen bir ilişkidir . Yani A'daki nesneler B'deki nesneleri kullanıyorsa, bağımlılıklar böyle devam etmelidir.

Bu bir şekilde keyfi. MVVM gibi diğer modellerde kontrol alt katlardan kolayca akar. Örneğin, görünen başlığı bir değişkene bağlı olan ve onunla değişen bir etiket ayarlayabilirsiniz. Ana nesneler her zaman kullanıcının etkileşimde olduğu ve işlerin çoğunluğunu yapan nesneler olduğu için, normal olarak yukarıdan aşağıya bağımlılıkların olması hala tercih edilir.

Yukarıdan aşağıya, yöntem çağrısı kullanırken aşağıdan yukarıya (tipik olarak) olaylar kullanırız. Olaylar, kontrol tam tersi bir şekilde aksa bile bağımlılıkların aşağı inmesine izin verir. Üst katman nesneleri, alt katmandaki olaylara abone olur. Alt katman, fişe takılan üst katman hakkında hiçbir şey bilmez.

Örneğin, tek bir yönü korumanın başka yolları da vardır:

• süreklilikler (bir lambda veya çağrılacak bir yöntem ve eşzamansız bir yönteme olay geçirilmesi)
• alt sınıflama (B'deki bir ana sınıfın A'sında bir alt sınıf oluşturun, bu daha sonra bir alt eklentiye benzeyen alt katmana enjekte edilir)

Matt Fenwick ve Kilian Foth'un daha önce anlattıklarına iki kuruş eklemek istiyorum.

Yazılım mimarisinin bir ilkesi, karmaşık programların daha küçük, kendi kendine yeten bloklar (siyah kutular) oluşturarak inşa edilmesi gerektiğidir: bu, bağımlılıkları en aza indirerek karmaşıklığı azaltır. Dolayısıyla, bu tek yönlü bağımlılık iyi bir fikir çünkü yazılımı anlamayı kolaylaştırıyor ve karmaşıklığı yönetmek yazılım geliştirmedeki en önemli konulardan biri.

Bu nedenle, katmanlı bir mimaride, alt katmanlar, üst katmanların inşa edildiği soyutlama katmanlarını uygulayan siyah kutulardır. Eğer bir alt katman (örneğin, B katmanı) bir üst katman A'nın ayrıntılarını görebilirse, o zaman B artık kara bir kutu değildir: uygulama detayları, kendi kullanıcısının bazı detaylarına bağlıdır, ancak kara kutu fikri, içeriği (uygulaması) kullanıcısı için önemli değil!

Sadece eğlence için.

Ponpon kızlar piramitini düşünün. Alt satır üstlerindeki satırları desteklemektedir.

Eğer o sıradaki amigo aşağı bakıyorsa, stabildir ve dengesiz kalacaktır, böylece onun üstünde kalanlar düşmez.

Yukarıdaki herkesin nasıl olduğunu görmeye çalışırsa, tüm yığının düşmesine neden olarak dengesini kaybedecek.

Gerçekten teknik değil, ama yardımcı olabileceğini düşündüğüm bir benzetme oldu.

Anlama kolaylığı ve bir dereceye kadar değiştirilebilen bileşenler kesinlikle iyi nedenler olsa da, eşit derecede önemli bir neden (ve muhtemelen katmanların ilk sırada icat edilmesinin nedeni) yazılım bakım bakış açısındandır. Sonuç olarak, bağımlılıkların potansiyelleri bir şeyler kırmalarına neden olmasıdır.

Örneğin, A'nın B'ye bağlı olduğunu varsayalım. Hiçbir şey A'ya bağlı olmadığından, geliştiriciler A'dan başka bir şeyi kırabileceklerinden endişe etmeden endişelenmeksizin kalp içeriğinde A'yı değiştirmekte özgürdürler. Ancak, geliştirici B'yi değiştirmek istiyorsa herhangi bir değişiklik yapabilir yapılan B'de potansiyel olarak A kırılabilir. Bu, erken bilgisayar günlerinde (yapılandırılmış gelişmeyi düşünün), geliştiricilerin programın bir bölümünde bir hatayı gidereceği ve programın başka bir yerde tamamen alakasız bölümlerinde hatalar doğuracağı sık görülen bir problemdi. Hepsi bağımlılıklar yüzünden.

Örneğe devam etmek için, şimdi A'nın B VE B'ye bağlı olduğunu varsayalım. A'ya bağlıdır. IOW, dairesel bir bağımlılık. Şimdi, herhangi bir yerde herhangi bir değişiklik yapıldığında, diğer modülü kırabilir. B'deki bir değişiklik hala A'yı kırabilir, ancak şimdi A'daki bir değişiklik B'yi de kırabilir.

Asıl sorunuza göre, eğer küçük bir proje için küçük bir takımdaysanız, o zaman tüm bunlar oldukça fazla göz ardı edilir çünkü hevesinizdeki modülleri özgürce değiştirebilirsiniz. Bununla birlikte, eğer büyük bir projedeyseniz, tüm modüller diğerlerine bağlıysa, bir değişiklik gerektiğinde her zaman diğer modülleri kırabilir. Büyük bir projede, tüm etkileri bilmek zor olabilir, bu yüzden muhtemelen bazı etkileri kaçıracaksınız.

Birçok geliştiricinin bulunduğu büyük bir projede daha da kötüye gidiyor (örneğin, bazıları yalnızca katman A, bazıları katman B ve bazıları katman C çalışıyor). Değişikliklerinizin kırılmadığından emin olmak için üzerinde çalıştıkları üzerinde çalışmayı zorlamak için her bir değişikliğin diğer katmanlardaki üyelerle incelenmesi / tartışılması gerekme olasılığı artar. Eğer değişiklikleriniz başkaları üzerinde değişiklik yapmaya zorlarsa, onları değişiklik yapmaları gerektiğine ikna etmeniz gerekir, çünkü modülünüzde bu yeni ve harika şeyleri yapma şekliniz olduğu için daha fazla iş almak istemeyeceklerdir. IOW, bürokratik bir kabus.

Ancak A'ya bağımlılıkları kısıtladığınızda B'ye, B'ye C'ye bağlı olursanız, o zaman sadece C katmanının değişikliklerini her iki takıma da koordine etmesi gerekir. B katmanının yalnızca Katman A ekibi ve katman A ile değişiklikleri koordine etmesi gerekir. Ekip kodları B veya C kodunu etkilemediği için istedikleri her şeyi yapmakta özgürdür. Dolayısıyla ideal olarak, katmanlarınızı tasarlayacaksınız, böylece katman C çok değişecek küçük, B katmanı biraz değişir ve A katmanı çoğu değiştirir.

Alt katmanların yüksek katmanların farkında olmamasının en temel nedeni, daha birçok tür yüksek katman bulunmasıdır. Örneğin, Linux sisteminizde binlerce ve binlerce farklı program var, ancak aynı C kütüphanesi mallocişlevini çağırıyorlar . Bu yüzden bağımlılık bu programlardan o kütüphaneye.

"Alt katmanlar" aslında orta katmanlardır.

Bazı aygıt sürücüleri aracılığıyla dış dünyayla iletişim kuran bir uygulamayı düşünün. İşletim sistemi ortada .

İşletim sistemi, uygulamalardaki ve cihaz sürücülerindeki ayrıntılara bağlı değildir. Aynı türde birçok aygıt sürücüsü vardır ve aynı aygıt sürücüsü çerçevesini paylaşırlar. Bazen çekirdek bilgisayar korsanları, belirli bir donanım ya da aygıt için çerçeveye bazı özel durumlar dahil etmek zorunda kalırlar (son örnek: Linux'un USB seri çerçevesinde PL2303'e özel kod). Bu olduğunda, genellikle bunun ne kadar berbat olduğu ve kaldırılması gerektiği hakkında yorumlar yaptılar. İşletim sistemi aramalarında sürücülerin işlevlerini çağırmasına rağmen, aramalar, sürücülerin aynı görünmesini sağlayan kancalardan geçer, oysa sürücüler işletim sistemini aradıklarında, genellikle belirli işlevleri doğrudan adlarıyla kullanırlar.

Yani, bazı açılardan, işletim sistemi gerçekten uygulamanın bakış açısıyla bir alt tabakasıdır ve işler bağlamak ve veri uygun yollar gitmek geçer iletişim merkezi bir tür: Uygulamanın bakış açısıyla. Herhangi bir cihazı veya uygulamayı belirli hackleri göbeğe taşımamak yerine, herhangi bir kişi tarafından kullanılabilecek esnek bir hizmeti dışa aktarmak için iletişim merkezinin tasarımına yardımcı olur.

Kaygıların ayrılması ve bölme / fethetme yaklaşımları bu sorular için başka bir açıklama olabilir. Kaygıların ayrılması taşınabilirlik kabiliyeti verir ve bazı daha karmaşık mimarilerde, platforma bağımsız ölçeklendirme ve performans avantajları sağlar.

Bu bağlamda, 5 katmanlı bir mimarlık (müşteri, sunum, iş, entegrasyon ve kaynak katmanı) hakkında daha düşük bir mimarlık seviyesine sahipseniz, daha yüksek seviyelerin mantığını ve işleyişinin farkında olmamalıdır; Entegrasyon ve kaynak seviyeleri olarak düşük seviyeyle kastediyorum. Entegrasyonda sağlanan veritabanı entegrasyon arayüzleri ve gerçek veritabanı ve web servisleri (3. parti veri sağlayıcılar) kaynak katmanına aittir. Bu nedenle, MySQL veritabanınızı ölçeklenebilirlik ya da her neyse MangoDB gibi bir NoSQL doküman DB'sine değiştireceğinizi varsayalım.

Bu yaklaşımda, işletme katmanı, entegrasyon katmanının kaynak tarafından bağlantı / aktarımı nasıl sağladığı ile ilgilenmez. Yalnızca entegrasyon katmanı tarafından sağlanan veri erişim nesnelerini arar. Bu, daha fazla senaryoya genişletilebilir ancak temelde endişelerin ayrılması bunun bir numaralı nedeni olabilir.

Kilian Foth'un cevabını genişleterek, bu katmanlaşma yönü bir insanın bir sistemi araştırdığı bir yöne karşılık gelir.

Katmanlı sistemdeki bir hatayı düzeltmekle görevli yeni bir geliştirici olduğunuzu hayal edin.

Hatalar, genellikle müşterinin ihtiyaç duyduğu ve sahip olduğu şey arasındaki uyumsuzluktur. Müşteri, UI üzerinden sistemle iletişim kurduğundan ve UI üzerinden sonuç aldığından (UI kelimenin tam anlamıyla 'kullanıcı arabirimi' anlamına gelir), hatalar da UI cinsinden rapor edilir. Yani, bir geliştirici olarak, ne olduğunu bulmak için, kullanıcı arayüzüne de bakmaya başlamaktan başka seçeneğiniz yok.

Bu nedenle yukarıdan aşağıya katman bağlantılarına sahip olmak gerekir. Şimdi, neden iki taraftan da bağlantı kuramıyoruz?

Peki, bu hatanın nasıl olabileceği ile ilgili üç senaryo var.

UI kodunun kendisinde olabilir ve bu nedenle orada yerelleştirilebilir. Bu kolay, sadece bir yer bulup düzeltmeniz gerekiyor.

UI'den yapılan aramalar sonucunda sistemin diğer bölümlerinde meydana gelebilir. Orta derecede zor olan bir çağrı ağacı izler, hatanın oluştuğu yeri bulur ve düzeltirsiniz.

Ve UI kodunuzu INTO bir arama sonucu oluşabilir. Zor olan, aramayı yakalamak, kaynağını bulmak, sonra hatanın nerede olduğunu bulmak zorundasınız. Başladığınız bir noktanın bir arama ağacının tek bir dalının derinliklerine yerleştirildiğini göz önünde bulundurarak VE önce doğru bir arama ağacı bulmanız gerekir, UI kodunda birkaç arama olabilir, hata ayıklama işleminiz sizin için kesilir.

En zor durumu olabildiğince ortadan kaldırmak için, dairesel bağımlılıklar kesinlikle önerilmez, katmanlar çoğunlukla yukarıdan aşağıya bağlanır. Bir bağlantı başka bir yönteme ihtiyaç duyulduğunda bile, genellikle sınırlıdır ve açıkça tanımlanmıştır. Örneğin, bir tür ters bağlantı olan geri aramalarda bile, geri aramada çağrılan kod, genellikle bu geri aramayı ilk etapta sağlar, ters bağlantı için bir tür "katılım" uygular ve bunların anlaşılması üzerindeki etkilerini sınırlandırır. sistemi.

Katmanlama bir araçtır ve öncelikle mevcut bir sistemi destekleyen geliştiricilere yöneliktir. Tabi, katmanlar arasındaki bağlantılar da bunu yansıtıyor.

Burada açıkça belirtilmek istediğim bir diğer neden, kodun yeniden kullanılabilirliğidir . Değiştirilen RS232 medya örneğini zaten aldık, bu yüzden bir adım daha ileri gidelim ...

Sürücü geliştirdiğini hayal edin. Bu senin işin ve epey demet yazıyorsun. Protokoller muhtemelen fiziksel medya gibi bir noktada tekrarlanmaya başlayabilir.

Öyleyse, yapmaya başlayacağınız şey - tekrar tekrar aynı şeyi yapmanın büyük bir hayranı olmadığınız sürece - bunlar için tekrar kullanılabilir katmanlar yazmaktır.

Modbus aygıtları için 5 sürücü yazmanız gerektiğini söyleyin. Biri Modbus TCP kullanıyor, ikisi RS485'te Modbus kullanıyor, gerisi RS232'yi kullanıyor. Modbus'u 5 kez yeniden yerleştirmeyeceksiniz çünkü 5 sürücü yazıyorsunuz. Ayrıca Modbus'u 3 kez tekrar uygulayamazsınız, çünkü altınızda 3 farklı Fiziksel katman var.

Yaptığınız şey, bir TCP Medya Erişimi, bir RS485 Medya Erişimi ve Muhtemelen bir RS232 Medya Erişimi yazmanızdır. Bu noktada yukarıda bir modbus katmanı olacağını bilmek akıllıca mı? Muhtemelen değil. Uygulayacağınız bir sonraki sürücü Ethernet de kullanabilir, ancak HTTP-REST kullanır. HTTP üzerinden iletişim kurmak için Ethernet Media Access'i yeniden uygulamak zorunda kalırsanız çok yazık olur.

Yukarıdaki bir katmanda, sadece bir kez Modbus uygulayacaksınız. Bu Modbus katmanı bir kez daha, bir kat yukarı çıkan sürücüleri bilmeyecek. Bu sürücüler elbette modbus konuşmaları gerektiğini ve Ethernet kullandıklarını bilmeleri gerekiyor. Az önce tarif ettiğim gibi uygulasaydım, sadece bir katmanı söküp değiştiremezsiniz. Tabii ki yapabilirsin - ve bu benim için en büyük yararı, devam et ve mevcut Ethernet katmanını, başlangıçta yaratılmasına neden olan projeyle kesinlikle alakasız bir şey için tekrar kullan.

Bu bir şey, muhtemelen her gün geliştiriciler olarak görüyoruz ve bu bize zaman kazandırıyor. Her çeşit protokol ve başka şeyler için sayısız Kütüphaneler var. Bunlar, yeniden kullanılabilir yazılım katmanları oluşturmamızı sağlayan komut yönünü izleyen bağımlılık yönü gibi prensipler nedeniyle mevcuttur.