PHP’deki bileşenlerle GraphQL sunucusunu uygulamak
GraphQL, müşterilere hangi verilere ihtiyaç duyduklarını sormalarını ve tam olarak böyle almalarını sağlayan bir sorgu dilidir. Bu şekilde, bir sorgu bileşenleri oluşturmak için gereken tüm verileri alabilir. (Bir karşılaştırma olarak bir dinlenme yangını, grafiği kullanarak grafiği kullanarak grafikkl (yani “grafik sorgu dili” anlamına gelir) olmasına rağmen, farklı uç noktalardan birçok kaynaktan veri almak için bazı alternatif gezileri tetiklemelidir. Veri Modeli Verileri temsil etmek için, GraphQL sunucusunun sorguyu tamamlamak için grafiği veri yapısı olarak kullanması gerekmez, ancak istenen veri yapısını kullanabilir. Grafikler sadece zihinsel modellerdir, gerçek uygulama değildir.
Bu, GraphQL projesi tarafından Graphql.org web sitesinde (benim vurgu) bildirilerek desteklenir: Grafik, birçok gerçek dünya fenomenini modellemek için güçlü bir araçtır, çünkü doğal zihinsel modellerimize ve altta yatan süreçlerin sözlü açıklamalarına benzemektedir. GraphQL ile, şemayı tanımlayarak işletme alanınızı grafik olarak modellersiniz; Şemanızda, çeşitli düğüm türlerini ve bunların birbirleriyle nasıl bağlandığını/ilişkili olduklarını belirlersiniz. İstemcilerde bu, nesne yönelimli programlamaya benzer kalıplar yapar: diğer türleri ifade eden tür. Sunucuda, GraphQL yalnızca arayüzü tanımladığından, herhangi bir arka uçla (yeni veya eski!) Kullanma özgürlüğüne sahipsiniz.
Bu iyi bir haberdir, çünkü grafikler veya ağaçlarla (grafiğin bir parçası kümesidir) uğraşmak önemsiz değildir ve sorguyu çözmek için üstel veya logaritmik zamanın karmaşıklığına neden olabilir (yani sorguyu tamamlamak için gereken süre kutu her yeni giriş için büyük siparişlerinin bazılarını sorgulamak için artırın). Bu makalede, GraphQL Server Mimari Tasarımını POP tarafından POP tarafından açıklayacağım, bu da bileşenleri grafik olarak değil bir veri yapısı olarak kullanıyor. Bu sunucu adını POP’a borçludur, PHP’de bileşenler oluşturmak için kütüphane temeldir. (Projenin ikinci yazarıyım.) Bu makale, şunları açıklayan 5 bölüme ayrılmıştır:
Bileşen nedir?
Pop nasıl çalışır
Bileşenler pop’da nasıl tanımlanır
Bileşenler GraphQL için doğal olarak nasıl uygundur?
Performans, GraphQL sorgularını tamamlamak için bileşenleri kullanır
Hadi başlayalım. 1. Bileşen nedir? Her web sayfasının düzeni bileşenler kullanılarak temsil edilebilir. Bileşen, sadece daha karmaşık yapılar yapmak için diğer bileşenleri sarabilen ve ayrıca diğer bileşenler tarafından sarılabilen, otonom varlıklar yapmak için birleştirilen ve aynı zamanda diğer bileşenler tarafından sarılan bir kod parçaları (HTML, JavaScript ve CSS gibi) bir koleksiyondur. Her bileşenin, bağlantılar veya düğmeler gibi çok temel bir şeyden Güney Kore veya sürükleme ve gevşek görüntüleri yükleme gibi çok karmaşık bir şeye kadar değişen bir amacı vardır.
LEGO ile oynamaya benzer bileşenler aracılığıyla siteler. Örneğin, aşağıdaki resmin web sayfasında, bir web sayfası alana kadar daha karmaşık yapılar (widget, bölüm, taraf, menüler) yapmak için basit bileşenler (bağlantılar, düğmeler, avatarlar) düzenlenmiştir: sayfa Bileşen kutusu tarafından gösterildiği gibi bir sarma bileşeni bileşenleri, hem istemci tarafı (JS Vue ve Reakt kütüphaneleri veya CSS Bootstrap ve Malzeme-UI bileşenleri gibi) ve sunucu tarafı için herhangi bir dilde uygulanabilir. 2. Pop Works Pop, Mimariyi sunucu tarafı bileşen modeline göre açıklar ve bileşen modelleri aracılığıyla PHP’de uygular.
Aşağıdaki bölümde, “bileşen” ve “modül” terimi dönüşümlü olarak kullanılır. Üst modülden son seviyeye kadar birbirini saran tüm modüllerin ilişki bileşeninin hiyerarşisi bileşen hiyerarşisi olarak adlandırılır. Bu ilişki, sunucu tarafındaki ilişkisel dizi (tuş => özellik dizisi) ile ifade edilebilir; PHP dizilerindeki veriler, JSON nesnesi olarak kodlanan doğrudan istemcinin tarafında da kullanılabilir. Bileşen hiyerarşisi şuna benziyor:
‘Modül-Level0’ => [
“Modüller” => [
‘Modül-Level1’ => [
“Modüller” => [
‘Modül-Level11’ => [
“Modüller” => […]
],
‘Modül-Level12’ => [
“Modüller” => [
‘Modül-Level121’ => [
“Modüller” => […]
]
]
]
]
],
‘Modül-Level2’ => [
“Modüller” => [
‘Modül-Level21’ => [“Modüller” => […]
]
]
]
]
]
]
Modüller arasındaki ilişki kesinlikle yukarıdan aşağıya tanımlanmıştır: modül başka bir modülü sarar ve kim olduklarını bilmek, ancak bilmiyor ve umursamıyor, hangi modül onu sardı.
Örneğin, yukarıdaki bileşen hiyerarşisinde, ‘Modül-Level1 Modülü modülü,’ Modül-Level11 ‘ve’ Modül-Level12 ‘modüllerini sardığını ve geçişli olarak’ Modül-Level121’i sardığını biliyordu; Ancak ‘Modül-Level11’ modülü, sonuç olarak ‘Modül-Level1’ bilmeden kimin sarıldığını umursamıyor. Bileşen bazlı bir yapıya sahip olan, ayarlara (yapılandırma ve diğer özellik değerleri gibi) kategorize edilen her modülün ihtiyaç duyduğu gerçek bilgileri (sorulan veritabanı kimliği ve diğer özellikler gibi) ekleriz ve altına göre yerleştiriliriz. Modülesetleme girişi ve modüledata:
$ ComponentHierarchyData = [
“Modulesettings” => [
‘Modül-Level0’ => [
“Yapılandırma” => […],
…,
“Modüller” => [
‘Modül-Level1’ => [
“Yapılandırma” => […],
…,
“Modüller” => [
‘Modül-Level11’ => [
… Çocuklar …
],
‘Modül-Level12’ => [
“Yapılandırma” => […],
…,
“Modüller” => [
‘Modül-Level121’ => [
… Çocuklar …
]
]
]
]
],
‘Modül-Level2’ => [
“Yapılandırma” => […],
…,
“Modüller” => [
‘Modül-Level21’ => [
… Çocuklar …
]
]
]
]
]
],
“Moduledata” => [
‘Modül-Level0’ => [
“Dbobjecids” => […],
…,
“Modüller” => [‘Modül-Level1’ => [
“Dbobjecids” => […],
…,
“Modüller” => [
‘Modül-Level11’ => [
… Çocuklar …
],
‘Modül-Level12’ => [
“Dbobjecids” => […],
…,
“Modüller” => [
‘Modül-Level121’ => [
… Çocuklar …
]
]
]
]
],
‘Modül-Level2’ => [
“Dbobjecids” => […],
…,
“Modüller” => [
‘Modül-Level21’ => [
… Çocuklar …
]
]
]
]
]
]
]
Ayrıca, bileşen hiyerarşisine veritabanı nesne verileri eklenir. Bu bilgiler her modülün altına değil, 2 veya daha fazla farklı modül veritabanından aynı nesneyi aldığında bilgileri çoğaltmayı önlemek için veritabanları adı verilen paylaşılan bölümün altına yerleştirilir.
Buna ek olarak, kütüphane, 2 veya daha fazla farklı veritabanı nesneleri genel nesnelerle (aynı yazara sahip 2 yayın gibi) ilişkili olduğunda bilgilerin çoğaltılmasını önlemek için veritabanı nesnesinin verilerini ilişkili olarak temsil eder. Başka bir deyişle, veri nesnesi verileri normalleştirilir. Yapı, her bir birinci nesne türü ve Nesne özelliğini alabileceğimiz ikinci bir nesne kimliği altında düzenlenmiş bir sözlüktir:
$ ComponentHierarchyData = [
…
“Veritabanları” => [
“dbobject_type” => [
“dbobject_id” => [
“Mülk” => …,,
…
],
…
],
…
]
]
Örneğin, aşağıdaki nesne, “Page” => “Post-Beed” adlı iki modül içeren bir bileşen hiyerarşisi içerir; Lütfen aşağıdakilere dikkat edin:
Her modül, DBObjectids özelliğinden sorulan nesneyi bilir (blog gönderimi için ID 4 ve 9)
Her modül, dbkeys özelliğinden sorduğu nesne için nesne türünü bilir (her gönderinin “yayınlar” altında bulunduğu veriler ve yazarın yayın verileri, yazılar “yazarı” yayınlarının altında verilen kimliğe göre, bulundu “Kullanıcılar”): Veritabanı nesne verileri ilişkisel olduğundan, “yazar” özelliği, yazarın verilerini doğrudan yazdırmak yerine yazarın nesnesine kimlik içerir
$ ComponentHierarchyData = [
“Moduledata” => [
‘Sayfa’ => [
“Modüller” => [
‘Post-feed’ => [
“Dbobjecids”: [4, 9]
]
]
]
],
“Modulesettings” => [
‘Sayfa’ => [
“Modüller” => [
‘Post-feed’ => [
“Dbkeys” => [
‘id’ => “gönderiler”,
‘Yazar’ => “kullanıcılar”
]
]
]
]
],
“Veritabanları” => [
‘Gönderiler’ => [
4 => [[
‘Başlık’ => “Merhaba dünya!”,
‘Yazar’ => 7
],
9 => [[
‘başlık’ => “Her şey yolunda mı?”,
‘Yazar’ => 7
]
],
‘Kullanıcılar’ => [
7 => [
‘İsim’ => “leo”
]
]
]
]
Veri Yükleme Modül, veritabanı nesnelerinden özellikleri görüntülediğinde, modül bilemeyebilir veya hangi nesnenin ne olduğunu önemsemeyebilir; Önemli olan, gerekli olan nesneden hangi özelliği tanımlamaktır. Örneğin, aşağıdaki resme dikkat edin: Modül veritabanından nesneler içerir (bu durumda, bir yazı) ve daha sonra türev modül, nesnenin “başlık” ve “içerik” gibi belirli özelliklerini görüntüleyecektir:
Bazı modüller veritabanı nesneleri içerirken, diğerleri özellik içerir, bu nedenle bileşen hiyerarşisi boyunca, “veri yükleme modülü” istenen nesneyi yüklemekten sorumlu olacaktır (modül bu durumda bir yazı içerir) ve türev modül irade İhtiyaç duyulan DB nesnelerinden (bu durumda “başlık” ve “içerik”) özelliği belirleyin. DB nesneleri için gereken tüm özellikleri almak, hiyerarşi bileşenini geçerek yapılabilir: veri yükleme modülünden başlayarak POP, yeni veri yükleme modülüne veya hiyerarşinin sonuna kadar tüm türev modüllerini tekrarlar; Her seviyede gerekli tüm özellikleri alır ve daha sonra tüm özellikleri birleştirir ve veritabanından sorar, her şey sadece bir kez olur. Veritabanı nesne verileri ilişkili olarak alındığından, bu stratejiyi veritabanı nesnesi arasındaki ilişkiler arasında da uygulayabiliriz. Aşağıdaki resme bakın: “Gönderi” nesnesinden başlayarak ve bileşen hiyerarşisine kadar, gönderinin yazarına göre veritabanı nesnesinin türünü “kullanıcı” ve “yorum” olarak değiştirmemiz gerekir. Her biri yorum sonrası ve ardından her yorum için, yorum yazarlarına göre nesne türünü bir kez daha “kullanıcı” olarak değiştirmelidir. Veritabanı nesnelerinden ilişkisel nesnelere geçmek “Etki Alanı Anahtar” dediğim şeydir. Yeni bir etki alanına geçtikten sonra, alt bileşen hiyerarşisindeki bu seviyeden, gerekli tüm özellikler yeni bir alana tabi olacaktır: “Ad” özelliği, yazının yazarını temsil eden “kullanıcı” nesnesinden alınır “İçerik” “From” dan ”
Yorum “Her yorumu temsil eden ve ardından” kullanıcı “ndan” ad “her yorumun yazarını temsil eder: DB nesnesini bir etki alanından başka bir etki alanına değiştirmek, bileşen hiyerarşisini geçer, Pop, alanı hareket ettirdiğini ve doğru bir şekilde bilir. İlişkisel nesne verilerini alın. 3. Modül pop özelliğinde (yapılandırma değeri, hangi veritabanı verilerinin alınacağı vb.) Ve türev modüller modülden sonra modül sonrası modüle göre tanımlanır ve POP İlgili tüm modülleri işleyen tüm modüllerin bileşen hiyerarşisi. React uygulamasına benzer şekilde (hangi bileşenlerin
içinde oluşturulduğunu göstermemiz gerekir), pop’daki bileşen modellerinin bir giriş modülü olması gerekir. Bundan başlayarak, pop Bileşen hiyerarşisindeki tüm modülleri geçecek, SupereProcessor’un her biri için mülk alacak ve tüm modüller için tüm özelliklere sahip ilişkisel diziler yuva yapar. Bir Bileşen türev bileşeni tanımlar, bileşen bunu 2 parça satırından ifade eder:
PHP sınıfı
Bileşen Adı
Bunun nedeni, bileşenlerin genellikle özelliği paylaşmasıdır. Örneğin, Post_thumbnail_large ve Post_thumbnail_small bileşenleri, küçük resim boyutu hariç, özelliklerin çoğunu paylaşır. Daha sonra, aynı PHP sınıfı altındaki tüm benzer bileşenleri gruplandırmak ve istenen modülleri tanımlamak ve uygun özelliği geri yüklemek için bir anahtar deyimi kullanmak mantıklıdır. Farklı sayfalara yerleştirilmesi için widget post bileşenleri için bir moduleprocessor şuna benziyor: Sınıf PostwidgetModuleprocessor SoyutModulessor {
const post_widget_homepage = ‘widget-gotpage sonrası’; const post_widget_authorpage = ‘widget-authorPage’;
İşlev getUbmodulestOprocess () {
dönüş [
Self :: Post_widget_homePage,
Self :: Post_widget_authorPage,
];
}
İşlev getUbmodules ($ modül): dizi
{
$ ret = [];
Switch ($ modül [1]) {
Case Self :: Post_widget_homePage:
Case Self :: Post_widget_AuthorPage:
$ ret [] = [
UserLayoutModuleprcessor :: sınıf,
UserLayoutModuleprocessor :: Post_thumb
];
$ ret [] = [
UserLayoutModuleprcessor :: sınıf,
UserLayoutModuleprocessor :: Post_title
];
kırmak;
}
Switch ($ modül [1]) {
Case Self :: Post_widget_homePage:
$ ret [] = [
UserLayoutModuleprcessor :: sınıf,
UserLayoutModuleprocessor :: Post_date
];
kırmak;
}
Geri dönüş $ ret;
}
Fonksiyon GetIMMutableConfiguration ($ Modül ve $ Props)
{
$ ret = [];
Switch ($ modül [1]) {
Case Self :: Post_widget_homePage:
$ ret [‘açıklama’] = __ (‘son gönderiler’, ‘benim alanım’);
$ ret [‘showmore’] = $ this-> getProp ($ modül, $ props, ‘showmore’);
$ ret [‘class’] = $ this-> getProp ($ modül, $ props, ‘sınıf’);
kırmak;
Case Self :: Post_widget_AuthorPage:
$ ret [‘açıklama’] = __ (‘Yazarın en son gönderileri’, ‘My-alanım’);
$ ret [‘showmore’] = false;
$ ret [‘class’] = ‘metin merkezi’;
kırmak;
}
Geri dönüş $ ret;
}
InitModelProps işlevi ($ modül ve $ props)
{
Switch ($ modül [1]) {
Case Self :: Post_widget_homePage:
$ this-> setProp ($ modül, $ props, ‘showmore’, yanlış);
$ this-> appendProp ($ modül, $ props, ‘sınıf’, ‘metin merkezi’);
kırmak;
}
Ana :: initModelProps ($ modül, $ props);
}
// …
}
Birkaç somutlaştırıcı sınıf tarafından uygulanması gereken yer tutucu işlevini tanımlayan soyut bir modülprocessor sınıfı oluşturarak yeniden kullanılabilecek bileşenler yapmak: Özet Sınıf PostwidgetLayeOtBtractModuless Soyutmodulessors’u genişletir
{
İşlev getUbmodules ($ modül): dizi
{
$ ret = [
$ this-> getContentModule ($ modül),
];
if ($ thumbnail_module = $ this-> getthumbnailmodule ($ modül))
{
$ ret [] = $ thumbnail_module;
}
if ($ dencontent_modules = $ this-> getAfttenmodules ($ modül))
{
$ ret = array_merge (
$ ret,
$ AfterConten_modules
);
}
Geri dönüş $ ret;
}
Özet korumalı işlev getContentModule ($ modül): dizi;
Korumalı işlev getthumbnailmodule ($ modül):?
{
// Varsayılan değer (geçersiz kılınabilir)
dönüş [self :: class, self :: thumbnail_layout];
}
Korumalı işlev getAfterconcentModules ($ modül): dizi
{
dönüş [];
}
Function GetIMMutableConfiguration ($ Modül ve $ Props): Dizi
{
dönüş [
‘Açıklama’ => $ this-> getDescription (),,
];
}
Korumalı işlev getDescription ($ modül): String
{
dönüş ”;
}
}
Özel Moduleprocessors sınıfı daha sonra soyut sınıfı genişletebilir ve mülkün kendisini belirleyebilir:
Sınıf PostLayoutModuless, AbstractPostLayoutModulessor {
const post_content = ‘içerik sonrası’
const Post_excerpt = ‘Ekspert sonrası’
const Post_thumbnail_large = ‘Thumbnail-Land’
const Post_thumbnail_medium = ‘Thumbnail-Medium sonrası’
const post_share = ‘paylaşım sonrası’
İşlev getUbmodulestOprocess () {
dönüş [
Self :: Post_content,
Self :: Post_excerpt,
Self :: Post_thumbnail_large,
Self :: Post_thumbnail_medium,
Self :: Post_share,
];
}
}
Sınıf PostwidgetLayoutModuleprocessor AbstractPostwidgetLayModumuleproector {
Korumalı işlev getContentModule ($ modül):?
{
Anahtar ($ Modül [1])
{
Case Self :: Post_widget_homePage_large:
dönüş [
PostLayoutModuleprocessor :: sınıf,
PostLayoutModuleprocessor :: Post_content
];
Case Self :: Post_widget_homePage_Medium:
Case Self :: Post_widget_homePage_small:
dönüş [
PostLayoutModuleprocessor :: sınıf,
PostLayoutModuleprocessor :: Post_excerpt
];
}
Dönüş ebeveyn :: getContentModule ($ modül);
}
Korumalı işlev getthumbnailmodule ($ modül):?
{
Anahtar ($ Modül [1])
{
Case Self :: Post_widget_homePage_large:
dönüş [
PostLayoutModuleprocessor :: sınıf,
PostLayoutModuleprocessor :: Post_thumbnail_large
];
Case Self :: Post_widget_homePage_Medium:
dönüş [
PostLayoutModuleprocessor :: sınıf,
PostLayoutModuleprocessor :: Post_thumbnail_medium
];
}
Dönüş ebeveyn :: getthumbnailModule ($ modül);
}
Korumalı işlev getAfterconcentModules ($ modül): dizi
{
$ ret = [];
Anahtar ($ Modül [1])
{
Case Self :: Post_widget_homePage_large:
$ ret [] = [
PostLayoutModuleprocessor :: sınıf,
PostLayoutModuleprocessor :: Post_share
];
Kırmak
}
Geri dönüş $ ret;
}
Korumalı işlev getDescription ($ modül): String
{
dönüş __ (‘Bunlar benim blog yayınlarım’, ‘benim alanım’);
}
}
4. GraphQL bileşen modelleri için doğal olarak nasıl uygun bileşenler doğal olarak GraphQL sorgularını ağaç şeklinde haritalayarak GraphQL sunucusunu uygulamak için ideal mimari hale getirebilir. POP by GraphQL, GraphQL sorgusunu uygun bileşen hiyerarşisine değiştirmek ve bir POP veri yükleme makinesi kullanarak tamamlamak için ModuleProcessor sınıfının gerekli olduğunu uygulamıştır. Bu yüzden ve bu çözümün nasıl çalıştığı budur. İstemcinin yan bileşenlerini GraphQL sorgusuna eşlemek GraphQL sorguları, her bir nesne türünün bir bileşeni temsil ettiği ve nesne türünden diğer nesne türlerine her bir ilişki alanı kullanılarak bir pop bileşeni hiyerarşisi kullanılarak temsil edilebilir. Diğer bileşenleri sarın. Bunun bir örnek kullanarak nasıl gerçekleştiğini görelim. Diyelim ki aşağıdaki “Üstün Yönetmen” Widget: Üstün Yönetmen widget’ı Vue veya React (veya diğer bileşen tabanlı kütüphaneler) kullanıyor, önce bileşenleri tanımlayacağız. Bu durumda, bileşenini (yeşil) doğal olarak sarmış olan <ctors) bileşenlerini saran bir dış bileşene sahip olacağız:
Sahte kod widget'ındaki bileşenleri tanımlamak şöyle görünüyor:
<!-Bileşen: ->
Ülke: {country}
{Film olarak film olarak film}
{/Her biri için}
<!-Bileşen: -> Başlık: {Başlık}Pic: {Thumbnail}
{aktör olarak aktör}
{/Her biri için}
<!-Bileşen: ->
İsim: {name}
Fotoğraf: {avatar}
Sonra her bileşen için hangi verilerin gerekli olduğunu belirleriz. için isimlere, avatarlara ve ülkelere ihtiyacımız var. Filmler için küçük resimlere ve başlıklara ihtiyacımız var. Ve için isimlere ve avatarlara ihtiyacımız var:
Her bileşen için veri özelliğini tanımlamak ve gerekli verileri almak için GraphQL sorgularımızı oluştururuz:
Sorgu {
featuredDirector {
İsim
Ülke
Avatar
Filmler {
Başlık
küçük resim
Aktörler {
Avatar
}
}
}
}
Takdir edilebileceği gibi, bileşen hiyerarşisi ve grafik sorguları arasında doğrudan bir ilişki vardır. Gerçekten de, GraphQL sorguları, bileşen hiyerarşisinin bir temsili olarak bile düşünülebilir. GraphQL sorgusu aynı bileşen hiyerarşisi formuna sahip olduğundan, POP’u eşdeğer bileşen hiyerarşisine değiştirerek, bileşenler için verileri almak ve son olarak sorgu formunu yeniden kullanan sorguları tamamlayarak, Sunucu Yan Bileşenini Kullanarak Komple GraphQL Sorguları Komple. Yanıt olarak veri gönderin. Bunun nasıl çalıştığını görelim. Verileri işlemek için POP, GraphQL türünü bir bileşene dönüştürür: => yönetmen, => film, => aktör kullanır ve sorgularda bir görünüm kullanır, pop, sanal bileşenlerin hiyerarşisini yapar, sanal bileşenlerin hiyerarşisi yapar Aynı öğe: Bileşenler: Aktör bileşenini saran film bileşenini saran Bileşenler Kök Yönetmeni. Şu andan itibaren, GraphQL veya pop bileşeni türü hakkında konuşmak farklı değil. Verilerini yüklemek için POP, bunları “yineleme” ile işler, yinelemenin kendisindeki her tür için nesne verileri alarak:
Verileri yüklemek için aşağıdaki sahte algoritmayı uygulayan pop veri yükleme makinesinin yinelemesindeki türü ile uğraşma: Hazırlık: Boş bir kuyruğun, türe göre düzenlenen veritabanından alınması gereken nesnenin bir listesini depolamak (( Her giriş: [Type => Kimlikler Listesi]) olacaktır.
Mükemmel yönetmenin nesne kimliğini alın ve yönetmen türü altındaki kuyruğa yerleştirin
Kuyrukta daha fazla giriş yapılmayana kadar tekrarlayın:
Kuyruktan ilk girişi alın: IDS türleri ve listesi (örneğin: Yönetmen ve [2]) ve bu girişi kuyruktan silin
Veritabanının bu tür için tüm nesneleri bu kimlikle alması için bir kuyruk çalıştırın
Türün ilişkisel bir düzlemi varsa (örneğin: Yönetmen Türü bir film tipi ilişkisel filmi var), o zaman mevcut yinelemede alınan tüm nesnelerin bu alanından tüm kimlikleri toplayın (örneğin:: Tür Nesnelerin tüm yöneticileri) ve bu kimliği kuyruğa uygun türün altına yerleştirin (örneğin: ID [3, 8] film türü altında).
Yinelemenin sonunda, bunun gibi tüm türler için tüm nesne verilerini içereceğiz:
Yinelemedeki türle uğraşarak lütfen bir tür için tüm kimliklerin nasıl toplandığına dikkat edin, böylece tür kuyrukta işlenir. Örneğin, ilişkisel tercihleri yönetmen türüne eklersek, bu kimlik aktör türü altındaki kuyruğa eklenir ve film türünden alan aktörünün kimliği ile birlikte işlenir:
Bununla birlikte, yinelemedeki türle ilgilenmek, eğer bir tür işlenmişse ve daha sonra bu türden daha fazla veri yüklememiz gerekiyorsa, bu tür yeni bir yinelemedir.Örneğin, Tercih Edilen İlişkileri Yazar Türüne eklemek, yönetmen türünü kuyruğa bir kez daha ekleyecektir:
Tekrarlanan tipte yineleme Ayrıca burada önbellekleme mekanizmasını kullanabileceğimizi unutmayın: Yönetmen tipi için ikinci yinelemede, ID 2 olan nesne tekrar alınmaz, çünkü ilk yinelemede alınmıştır, böylece önbellekten alınmıştır. Artık tüm nesne verilerini aldığımıza göre, GraphQL kuyruğunu yansıtarak beklenen yanıtı oluşturmamız gerekiyor. Bugün olduğu gibi, veriler ilişkisel veritabanında olduğu gibi ayarlanmıştır: Yönetmen Türü Tablo: Avatar Filminin Adı
8
Klon Saldırısı
bölüm-2.jpg
[6, 7] Aktör türü: Indo Avatar Adı
4
ewan mcgregor
mcgregor.jpg
6
>
Bu aşamada Pop, tüm verileri tablo olarak düzenledi ve her türün birbiriyle nasıl ilişkili olduğunu (yani film referans yönetmeni, aktör referans filmi aracılığıyla sahadan n aktörler). Daha sonra, kök hiyerarşisini tekrarlayarak, ilişkileri gezerek ve ilişkisel tablodan uygun nesneleri alarak POP, GraphQL Quents'ten ağaç şekilleri üretecektir: son ağaç şekilli tepki, çıkışa yazdırma verileri aynı şekilde bir yanıt üretir GraphQL sorgu formu:
{Veri: {
featuredDirector: {
İsim: "George Lucas",
Ülke: "ABD",
Avatar: "George-Lucas.jpg",
Filmler: [
{ Başlık: "Yıldız Savaşları: Bölüm I", Küçük resim: "bölüm-1.jpg", Aktörler: [ {
İsim: "Ewan McGregor",
Avatar: "McGregor.jpg",
},
{
İsim: "Natalie Portman",
Avatar: "Portman.jpg",
}
]
},
{
Başlık: "Yıldız Savaşları: Bölüm II",
Küçük resim: "bölüm-2.jpg",
Aktörler: [
{
İsim: "Natalie Portman",
Avatar: "Portman.jpg",
},
{
İsim: "Hayden Christensen",
Avatar: "Christensen.jpg",
}
]
}
]
}
}
}
