നിങ്ങളുടെ സ്വന്തം ചട്ടക്കൂട് വികസിപ്പിക്കുന്നതിനെക്കുറിച്ചുള്ള ആദ്യ ലേഖനം പുതിയ ചട്ടക്കൂടിൻ്റെ പ്രധാന ഉദ്ദേശിച്ച കഴിവുകളുടെയും വാസ്തുവിദ്യാ സവിശേഷതകളുടെയും ഒരു അവലോകനത്തിനായി നീക്കിവച്ചിരിക്കുന്നു. ഇവിടെ ഞാൻ മൊഡ്യൂളുകളും ഘടകങ്ങളും വിവരിക്കും, അതിൻ്റെ വികസനം തുടർന്നുള്ള ലേഖനങ്ങളിൽ വിശദമായി വിവരിക്കും. അതിനാൽ, ചട്ടക്കൂടിൻ്റെയും അത് ഉപയോഗിക്കുന്ന ആപ്ലിക്കേഷനുകളുടെയും കോഡ് എങ്ങനെ ഓർഗനൈസ് ചെയ്യണമെന്ന് നമുക്ക് തീരുമാനിക്കാം, തുടർന്ന് പ്രധാന ഘടകങ്ങളുടെ വികസനത്തിനായി ഞങ്ങൾ ഒരു റോഡ്മാപ്പ് സൃഷ്ടിക്കും.

ആരംഭിക്കുന്നതിന്, ഞാൻ ലളിതവും സംക്ഷിപ്തവുമായ ഒരു പ്രോജക്റ്റ് ഡയറക്ടറി ഘടന തിരഞ്ഞെടുത്തു:

/
• app – webroot സെർവറിൻ്റെ ഡയറക്ടറി, ഇവിടെ index.php ഇടുക
  • പൊതുവായത് - ഇവിടെ ഞങ്ങൾ സ്റ്റാറ്റിക് ആപ്ലിക്കേഷൻ ഫയലുകൾ സംഭരിക്കും
• src - ആപ്ലിക്കേഷൻ്റെ തന്നെ സോഴ്സ് കോഡ് ഉള്ള ഡയറക്ടറി
  • ബ്ലോഗ് - ഓരോ ആപ്ലിക്കേഷനും അതിൻ്റേതായ ഡയറക്ടറിയിൽ സ്ഥിതിചെയ്യുന്നു
• lib - ബാഹ്യ ലൈബ്രറികൾക്കുള്ള ഡയറക്ടറി. ഫ്രെയിംവർക്ക് കോഡും ഇവിടെ സ്ഥിതിചെയ്യും.
• var - ആപ്ലിക്കേഷൻ ഫയലുകൾക്കുള്ള ഡയറക്ടറി (കാഷെ, ഫയൽ സംഭരണം, സെഷനുകൾ മുതലായവ)

ഞങ്ങൾ ഡയറക്ടറികൾ തീരുമാനിച്ചു. ഇപ്പോൾ നമുക്ക് വ്യക്തിഗത ആപ്ലിക്കേഷൻ ഘടകങ്ങളെ വ്യത്യസ്‌ത ഡയറക്‌ടറികളായി വേർതിരിക്കാനും ക്ലാസുകൾ ഓട്ടോലോഡ് ചെയ്യാൻ PSR0 ഉപയോഗിക്കാനും കഴിയും.
അടുത്തതായി, ലിബിനുള്ളിൽ ഒരു ഡയറക്‌ടറി സൃഷ്‌ടിക്കുന്നതിന് നിങ്ങൾ ചട്ടക്കൂടിൻ്റെ പേര് തിരഞ്ഞെടുക്കേണ്ടതുണ്ട്. രണ്ടുതവണ ആലോചിക്കാതെ, ഞാൻ ബൺ എന്ന പേര് തിരഞ്ഞെടുത്തു - ഹ്രസ്വവും അവിസ്മരണീയവും ഒന്നിലും വൈരുദ്ധ്യമില്ലെന്ന് തോന്നുന്നു.

ലിബിനുള്ളിൽ ഞങ്ങൾ ഒരു ബൺ ഡയറക്‌ടറി (വെണ്ടറുടെ നെയിംസ്‌പേസ്) സൃഷ്‌ടിക്കുന്നു, അതിൽ മറ്റൊരു ബൺ ഡയറക്‌ടറി (ലൈബ്രറിയുടെ നെയിംസ്‌പെയ്‌സ്), അതിനുള്ളിൽ src - ഇവിടെ ഞങ്ങൾ ഞങ്ങളുടെ ചട്ടക്കൂടിൻ്റെ കോഡ് സ്ഥാപിക്കും. ഈ സങ്കീർണ്ണമായ ഡയറക്‌ടറി ഘടന ഭാവിയിൽ അനാവശ്യ പ്രശ്‌നങ്ങളില്ലാതെ http://packagist.org വഴി ഫ്രെയിംവർക്ക് ബന്ധിപ്പിക്കാൻ ഞങ്ങളെ അനുവദിക്കും.

അടുത്തതായി, ചട്ടക്കൂടിൻ്റെ അടിസ്ഥാന ക്ലാസുകൾക്കായി ഒരു നെയിംസ്പേസ് തിരഞ്ഞെടുക്കുക - ഞാൻ കോർ തിരഞ്ഞെടുത്തു. ഭാവിയിൽ കോർ ഡയറക്ടറിക്ക് പുറത്തുള്ള ഘടകങ്ങളുടെ കണക്ഷൻ സംഘടിപ്പിക്കുന്നതിന്, നിങ്ങൾ ചട്ടക്കൂടിൻ്റെ ഒരു മോഡുലാർ ഘടന സംഘടിപ്പിക്കേണ്ടതുണ്ട്. അതിനാൽ, എൻ്റെ പക്കലുള്ള സിസ്റ്റത്തിൻ്റെ ആദ്യ ഘടകം ഒരു മൊഡ്യൂൾ ആണ് (ബൺ\കോർ\മൊഡ്യൂൾ).

ബൺ\കോർ\മൊഡ്യൂൾ

മൊഡ്യൂൾ ഒരു സ്വതന്ത്ര ചട്ടക്കൂട് ഘടകത്തിലേക്ക് അടിസ്ഥാന വിവരങ്ങൾ നൽകണം. ആരംഭിക്കുന്നതിന്, മൊഡ്യൂൾ ഉപയോഗിക്കുന്ന കോൺഫിഗറേഷനുകളും ഡിപൻഡൻസികളും, പതിപ്പ്, മൊഡ്യൂളിൻ്റെ വിവരണം മുതലായവ. lib/bun/bun/src-നുള്ളിലെ ഓരോ ഡയറക്‌ടറിയും ഒരു പ്രത്യേക മൊഡ്യൂളായിരിക്കും, അതേ പേരിൽ ഒരു ക്ലാസ് ഉണ്ടായിരിക്കണം (ഉദാഹരണത്തിന്, Bun\Core\Core.php) - ഇത് മൊഡ്യൂളിൻ്റെ നിർവ്വഹണത്തെ പ്രതിനിധീകരിക്കുന്നു.

ബൺ\കോർ\അപ്ലിക്കേഷൻ

ആപ്ലിക്കേഷൻ ഫ്രണ്ട് കൺട്രോളർ പാറ്റേണിൻ്റെ ഒരു നിർവ്വഹണമാണ് - എല്ലാ അഭ്യർത്ഥനകൾക്കും ആപ്ലിക്കേഷനിലേക്കുള്ള ഒരൊറ്റ എൻട്രി പോയിൻ്റ്. php cli അല്ലെങ്കിൽ സ്റ്റാറ്റിക് ഫയലുകൾക്കുള്ള അഭ്യർത്ഥനകൾ ഉൾപ്പെടെയുള്ള എല്ലാ അഭ്യർത്ഥനകളും ആപ്ലിക്കേഷനിൽ പ്രോസസ്സ് ചെയ്യണമെന്ന് ബൺ ആർക്കിടെക്ചർ നൽകുന്നു. index.php-ൽ ഒരു ആപ്ലിക്കേഷൻ ഉദാഹരണം സൃഷ്ടിക്കപ്പെടും (ആപ്ലിക്കേഷൻ ആരംഭിക്കുമ്പോൾ, അതിൻ്റെ എക്സിക്യൂഷൻ എൻവയോൺമെൻ്റ് (ഉത്പാദനം, വികസനം, പരിശോധന മുതലായവ) സൂചിപ്പിക്കും. കോൺഫിഗറേഷൻ ലോഡുചെയ്യുക, സേവന കണ്ടെയ്‌നർ ആരംഭിക്കുക, സഹായ ഘടകങ്ങളിലൂടെ അഭ്യർത്ഥനകൾ റൂട്ടിംഗ് ചെയ്യുക, കൺട്രോളറുകളെ വിളിക്കുക, പ്രതികരണം നൽകുക, ആപ്ലിക്കേഷൻ അവസാനിപ്പിക്കുക തുടങ്ങിയ ജോലികൾ ആപ്ലിക്കേഷൻ ചെയ്യും.

ഒരു ആപ്ലിക്കേഷൻ ആരംഭിക്കുമ്പോൾ നമ്മൾ ആദ്യം ചെയ്യുന്നത്, ചട്ടം പോലെ, കോൺഫിഗറേഷൻ ഫയലുകൾ ലോഡ് ചെയ്യുക എന്നതാണ്, അതിനാൽ അടുത്ത അടിസ്ഥാന ഘടകം കോൺഫിഗറായിരിക്കും

ബൺ \ കോർ \ കോൺഫിഗർ

ആപ്ലിക്കേഷനും ചട്ടക്കൂട് ഘടകങ്ങളും കോൺഫിഗർ ചെയ്യുന്നതിന്, ഒരു പ്രത്യേക സെറ്റ് ക്ലാസുകൾ അനുവദിച്ചിരിക്കുന്നു - ബൺ\കോർ\കൺഫിഗ്\അപ്ലിക്കേഷൻകൺഫിഗ് - കോൺഫിഗറേഷനുകൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള സേവനവും ബൺ\കോർ\കൺഫിഗ്\അബ്‌സ്‌ട്രാക്റ്റ് കോൺഫിഗ് ക്ലാസും - അടിസ്ഥാന ക്ലാസായ ഒരു അമൂർത്ത ക്ലാസ് കോൺഫിഗറേഷൻ ഘടകങ്ങൾ. കോൺഫിഗറേഷൻ ഫോർമാറ്റായി PHP ക്ലാസ് തിരഞ്ഞെടുത്തു. കാഷിംഗ് വീക്ഷണകോണിൽ നിന്ന് ഇത് സൗകര്യപ്രദമാണ്, അതായത്. xml, json, ini, മുതലായ ഫോർമാറ്റുകളിൽ പ്രത്യേക ഫയലുകൾ ഉപയോഗിക്കുന്നതിനേക്കാൾ കോൺഫിഗറുകൾ ആപ്ലിക്കേഷൻ കോഡിൽ നേരിട്ട് സംഭരിക്കുന്നത് കൂടുതൽ ലാഭകരമാണ്.

ക്ലാസുകൾ കോൺഫിഗറുകളായി ഉപയോഗിക്കുന്നത് വ്യക്തിഗത ഘടകങ്ങളുടെയും ആപ്ലിക്കേഷൻ്റെ ഭാഗങ്ങളുടെയും കോൺഫിഗറേഷനുകൾ വേർതിരിക്കുന്നതിനും സൗകര്യപ്രദമാണ്. ഒരു ആപ്ലിക്കേഷനിലെ ഡിഫോൾട്ട് ഫ്രെയിംവർക്ക് ക്രമീകരണങ്ങൾ അല്ലെങ്കിൽ ഒരു നിർദ്ദിഷ്ട നിർവ്വഹണ പരിതസ്ഥിതിയിലെ ആപ്ലിക്കേഷൻ ക്രമീകരണങ്ങൾ മറികടക്കുന്നതിനും ഇത് സൗകര്യപ്രദമാണ്. ഡിസൈൻ പ്രകാരം, ഓരോ മൊഡ്യൂളിലും ആപ്ലിക്കേഷനിലും കോൺഫിഗറേഷൻ ക്ലാസുകൾ സംഭരിച്ചിരിക്കുന്ന കോൺഫിഗറേഷൻ നെയിംസ്പേസ് അടങ്ങിയിരിക്കുന്നു. ഓരോ ക്ലാസിനും അതിൻ്റേതായ നെയിംസ്പേസ് ഉണ്ട്, കൂടാതെ ഒരു സംരക്ഷിത പ്രോപ്പർട്ടിയിൽ ഒരു അറേ ആയി കോൺഫിഗറേഷൻ പാരാമീറ്ററുകൾ സംഭരിക്കുന്നു.
$config->get("name1.name2.param1") എന്ന ഡോട്ട് നോട്ടേഷൻ വഴിയാണ് കോൺഫിഗറുകളിലേക്കുള്ള പ്രവേശനം അനുമാനിക്കുന്നത്.

ഞങ്ങൾ ആപ്ലിക്കേഷൻ കോൺഫിഗറേഷൻ ആരംഭിച്ച ശേഷം, ഞങ്ങൾക്ക് അഭ്യർത്ഥന പ്രോസസ്സ് ചെയ്യാൻ ആരംഭിക്കാം. വെബ് ആപ്ലിക്കേഷനുകളിൽ നിന്നുള്ള അഭ്യർത്ഥനകളും പ്രതികരണങ്ങളും ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നതിന് Http ഘടകങ്ങളുടെ ഒരു പ്രത്യേക സെറ്റ് അനുവദിച്ചിരിക്കുന്നു

ബൺ\കോർ\Http

സൂപ്പർഗ്ലോബൽ വേരിയബിളുകളായ $_SERVER, $_GET, $_POST എന്നിവയുമായി പ്രവർത്തിക്കുന്നതിൽ നിന്നും സംഗ്രഹിക്കുന്നതിന് Http ഘടകങ്ങളുടെ കൂട്ടം ഉത്തരവാദിയായിരിക്കും. ബൺ\കോർ\Http\അഭ്യർത്ഥന സേവനം ഇതിന് ഉത്തരവാദിയായിരിക്കും. കൂടാതെ, Http പ്രതികരണ ക്ലാസ് ഉൾപ്പെടുത്തും - ഇത് ആപ്ലിക്കേഷൻ്റെ ഫലത്തിൻ്റെ സ്റ്റാൻഡേർഡായിരിക്കും, അതായത്. കൺട്രോളർ സമാരംഭിക്കുന്നത് Bun\Core\Http\Response ഒബ്‌ജക്റ്റ് ലഭിക്കുന്നതോടെ അവസാനിക്കണം. http തലക്കെട്ടുകൾ മുതലായവയിൽ പ്രവർത്തിക്കുന്നതിൽ നിന്നും ഈ ക്ലാസ്സ് ഞങ്ങളെ സംഗ്രഹിക്കുന്നു. കൂടാതെ, AjaxResponse, DownloadResponse, ConsoleResponse മുതലായ ഡിറൈവ്ഡ് ക്ലാസുകൾ ഉപയോഗിക്കുന്നത് സൗകര്യപ്രദമാണ്.

അഭ്യർത്ഥനയെക്കുറിച്ചുള്ള വിവരങ്ങൾ ലഭിക്കാൻ ഞങ്ങൾ തയ്യാറാകുമ്പോൾ, ഞങ്ങൾക്ക് റൂട്ടിംഗിലേക്ക് പോകാം: അടുത്ത ഘടകം റൂട്ടർ ആണ്

ബൺ\കോർ\റൂട്ടർ

ആധുനിക PHP വെബ് ആപ്ലിക്കേഷനുകളുടെ ഒരു സാധാരണ ഘടകമാണ് റൂട്ടർ. കൺട്രോളർ ക്ലാസുകളിലേക്കും അവയുടെ പ്രവർത്തനങ്ങളിലേക്കും മാപ്പ് ചെയ്‌തിരിക്കുന്ന URL അഭ്യർത്ഥന ടെംപ്ലേറ്റുകളുടെ ഒരു നിരയുടെ രൂപത്തിലുള്ള ലളിതമായ കോൺഫിഗറായ ബൺ ഫ്രെയിംവർക്ക് റൂട്ടറിൽ അസാധാരണമായ ഒന്നും തന്നെയില്ല. /page/view/:page_id പോലുള്ള ഒരു url-ൽ നിന്ന് പാരാമീറ്ററുകൾ പാഴ്‌സ് ചെയ്യാനുള്ള കഴിവ് നടപ്പിലാക്കാൻ ഞാൻ പദ്ധതിയിടുന്നു - ഇത് കൺട്രോളർ പ്രവർത്തനത്തിലേക്ക് ആർഗ്യുമെൻ്റുകളായി കൈമാറും. രീതി അനുസരിച്ച് അഭ്യർത്ഥനകൾ വേർതിരിക്കാനും ഞാൻ പദ്ധതിയിടുന്നു (ചില രീതികൾ POST വഴി മാത്രമേ വിളിക്കാൻ കഴിയൂ - ബിസിനസ് ലോജിക് കോഡിൽ അനാവശ്യ പരിശോധനകൾ നടത്തേണ്ടതില്ല)

ഞങ്ങൾ PHP ആപ്ലിക്കേഷനുകളുടെ ഒരു സ്റ്റാൻഡേർഡ് ഘടകത്തിൽ നിന്ന് മറ്റൊന്നിലേക്ക് നീങ്ങുന്നു - അഭ്യർത്ഥന റൂട്ടിംഗ് MVC (മോഡൽ വ്യൂ കൺട്രോളർ) പാറ്റേൺ നടപ്പിലാക്കുന്നതുമായി അടുത്ത ബന്ധപ്പെട്ടിരിക്കുന്നു. ആപ്ലിക്കേഷൻ ലോജിക്, ഡാറ്റ, ഡിസ്പ്ലേ എന്നിവ വേർതിരിക്കുന്നത് ഇതിൽ ഉൾപ്പെടുന്നു.

ബൺ ഫ്രെയിംവർക്ക് എംവിസി

എംവിസി നടപ്പിലാക്കുന്നതിൽ സ്വയം വേർതിരിച്ചറിയാൻ പ്രയാസമാണ് - അതിനാൽ ഇവിടെയുള്ളതെല്ലാം തികച്ചും സാങ്കൽപ്പികമാണ്. കോറിനുള്ളിൽ, ഞാൻ കൺട്രോളർ നെയിംസ്‌പെയ്‌സ് അനുവദിക്കുന്നു - ഇവിടെ ഞാൻ സിസ്റ്റത്തിൻ്റെ എല്ലാ ഘടകങ്ങളിലേക്കും ആക്‌സസ് ഉള്ള ഒരു അടിസ്ഥാന കൺട്രോളർ ക്ലാസ് സൃഷ്ടിക്കുന്നു, അത് സമാരംഭിച്ച ആപ്ലിക്കേഷൻ്റെ ഒബ്‌ജക്റ്റ് സംഭരിക്കുന്നു, ഒരു കോൺഫിഗർ സേവനവും. സമാരംഭിക്കുമ്പോൾ, കൺട്രോളറിന് ലോഞ്ച് പാരാമീറ്ററുകൾ ലഭിക്കുന്നു: രീതിയുടെ പേരും (പ്രവർത്തനം) അതിൻ്റെ ആർഗ്യുമെൻ്റുകളും.

കോറിനുള്ളിലെ ഒരു പ്രത്യേക വ്യൂ ഡയറക്‌ടറിയിലേക്ക് ഞാൻ ഡിസ്‌പ്ലേ കോഡ് അലോക്കേറ്റ് ചെയ്യുന്നു. ബൺ ഫ്രെയിംവർക്ക് വ്യൂ തരത്തിൻ്റെ പ്രത്യേക ഘടകങ്ങളൊന്നും നൽകുന്നില്ല - നിങ്ങൾ കൺട്രോളറിനുള്ളിൽ ആവശ്യമുള്ള ടെംപ്ലേറ്റ് വലിച്ചിടുകയും ഡാറ്റ കൈമാറുകയും ചെയ്യുന്നുവെന്ന് അനുമാനിക്കപ്പെടുന്നു. സ്ഥിരസ്ഥിതിയായി, Twig ടെംപ്ലേറ്റ് എഞ്ചിനുള്ള പിന്തുണയും നേറ്റീവ് *.phtml ടെംപ്ലേറ്റുകൾക്കുള്ള പിന്തുണയും ചട്ടക്കൂടിലേക്ക് ചേർക്കാൻ ഞാൻ ഉദ്ദേശിക്കുന്നു.

അവസാന ഘടകം മോഡൽ ആണ്. കോർ: മോഡലിനുള്ളിൽ ഞാൻ അതിനായി ഒരു പ്രത്യേക നെയിംസ്‌പെയ്‌സും അനുവദിച്ചു. ഇവിടെയാണ് ചട്ടക്കൂടിൻ്റെ മറ്റൊരു അടിസ്ഥാന ഘടകം - ഒബ്ജക്റ്റ് മാപ്പർ. മോഡലുകൾ സ്വയം ക്ലാസുകളാണ്, അതായത്. ActiveRecord അല്ല, എന്നാൽ അവർ ഒരു നിശ്ചിത Bun\Core\Model\ModelInterface നടപ്പിലാക്കുന്നു. ഈ ക്ലാസുകളാണ് ഒബ്ജക്റ്റ്മാപ്പറിന് പ്രവർത്തിക്കാനും അവയെ ഏതെങ്കിലും തരത്തിലുള്ള സ്റ്റോറേജിലേക്ക് സംരക്ഷിക്കാനും കഴിയുന്നത്.

ഇപ്പോൾ നമുക്ക് ഒബ്ജക്റ്റ് മാപ്പറിനെയും സംഭരണത്തെയും കുറിച്ച് സംസാരിക്കണം, ആദ്യത്തേതിൽ നിന്ന് ആരംഭിക്കാം.

ബൺ \ കോർ \ ഒബ്ജക്റ്റ് മാപ്പർ

ഫ്രെയിംവർക്കിൻ്റെ കോർ മൊഡ്യൂളിൻ്റെ ഏറ്റവും സങ്കീർണ്ണമായ ഭാഗമാണ് ഒബ്‌ജക്റ്റ് മാപ്പർ. ചില ഡാറ്റാബേസിലെ ഒരു മോഡൽ ഒബ്‌ജക്‌റ്റിനെ റെക്കോർഡുകളാക്കി മാറ്റാൻ കഴിയുന്ന ഒരു സേവനമായിരിക്കും ഇത്, കൂടാതെ വിപരീതവും ചെയ്യുന്നു - ഡാറ്റ സ്റ്റോറിൽ നിന്ന് ഒരു റെക്കോർഡ് എടുത്ത് അതിനെ ഒരു മോഡൽ ഒബ്‌ജക്റ്റിലേക്ക് മാപ്പ് ചെയ്യുക. സ്ഥിരസ്ഥിതിയായി, ഒബ്‌ജക്റ്റുകളുടെ ഫയൽ സംഭരണം നടപ്പിലാക്കുന്ന ഒരു സേവനം കോർ മൊഡ്യൂളിൽ ഉൾപ്പെടുത്തും.

ബൺ\കോർ\സ്റ്റോറേജ്

ഒരു ആപ്ലിക്കേഷനിലെ ഏത് സ്റ്റോറേജ് ഇംപ്ലിമെൻ്റേഷനും പിന്തുടരേണ്ട അമൂർത്തീകരണത്തെയും ഇൻ്റർഫേസുകളെയും സ്റ്റോറേജ് ഘടക സെറ്റ് പ്രതിനിധീകരിക്കുന്നു. അത്തരം ആദ്യത്തെ സംഭരണം ബൺ\കോർ\സ്റ്റോറേജ്\ഫയൽസ്റ്റോറേജ് ആയിരിക്കും. പ്രവർത്തിപ്പിക്കുന്നതിന്, ഫയൽ സ്റ്റോറേജ് ഫയലുകളുമായി പ്രവർത്തിക്കുന്നതിന് ഒരു കൂട്ടം സഹായ ക്ലാസുകൾ ഉപയോഗിക്കും, അതുപോലെ തന്നെ ഫയൽ സ്റ്റോറേജിൽ റെക്കോർഡുകൾക്കായി തിരയുന്നതിനുള്ള അന്വേഷണങ്ങൾ നിർമ്മിക്കും.

മുകളിൽ വിവരിച്ച ഒബ്‌ജക്‌റ്റ് മാപ്പറിന് അതിൻ്റെ ഒബ്‌ജക്റ്റുകൾ അവിടെ സംഭരിക്കുന്നതിന് സ്‌റ്റോറേജിൻ്റെ ഏത് നടപ്പാക്കലിലും പ്രവർത്തിക്കാൻ കഴിയും. കോർ മൊഡ്യൂളിൻ്റെ മറ്റൊരു പ്രധാന ഘടകം ഇവിടെ ഹൈലൈറ്റ് ചെയ്യുന്നത് മൂല്യവത്താണ് - റിപ്പോസിറ്ററി.

ബൺ\കോർ\റിപ്പോസിറ്ററി

ഒരു ഒബ്‌ജക്‌റ്റിലേക്കുള്ള പ്രവേശനത്തിൻ്റെ ഒരു പാളിയാണ് ശേഖരണങ്ങൾ. ഒബ്‌ജക്‌റ്റ് മാപ്പർ തിരച്ചിൽ പ്രവർത്തനക്ഷമതയും റിപ്പോസിറ്ററിയിൽ നിന്നുള്ള ഒബ്‌ജക്‌റ്റുകളുടെ വിവിധ തിരഞ്ഞെടുപ്പുകളും ഉപയോഗിച്ച് ഓവർലോഡ് ചെയ്യാതിരിക്കാൻ, ഈ വർക്ക് റിപ്പോസിറ്ററിയിലേക്ക് മാറ്റി. റിപ്പോസിറ്ററിക്ക് നേരിട്ട് റിപ്പോസിറ്ററിയുമായി പ്രവർത്തിക്കാനും അവിടെ നിന്ന് ഡാറ്റ തിരഞ്ഞെടുക്കാനും തുടർന്ന് ഒബ്‌ജക്റ്റ് മാപ്പർ വഴി ഒബ്‌ജക്‌റ്റുകളായി മാറ്റാനും അപ്ലിക്കേഷനിലേക്ക് മാറ്റാനും കഴിയും.

മുകളിൽ വിവരിച്ച ഘടകങ്ങളുമായി ബന്ധപ്പെട്ട എന്തെങ്കിലും ഞാൻ ഉടൻ പരാമർശിക്കട്ടെ - കാഷെ

ബൺ\കോർ\കാഷെ

കാഷെ - Redis, Memacached മുതലായവ പോലുള്ള വിവിധ കാഷെ സ്റ്റോറേജുകളുമായുള്ള ഇടപെടൽ നടപ്പിലാക്കുന്നതിനുള്ള ഒരു കൂട്ടം സംഗ്രഹങ്ങൾ അടങ്ങിയിരിക്കും. കൂടാതെ, കോർ മൊഡ്യൂളിൽ FileCacheDriver ഘടകം ഉൾപ്പെടും, അത് ഫയലുകളിൽ ഡാറ്റ കാഷിംഗ് നടപ്പിലാക്കുന്നു.

ഇവിടെ നമ്മൾ പ്രധാനപ്പെട്ടതും എൻ്റെ അഭിപ്രായത്തിൽ ചട്ടക്കൂടിൻ്റെ വാസ്തുവിദ്യയെ നിർവചിക്കുന്നതുമായ ഒരു ഘടകത്തിലേക്ക് നീങ്ങുന്നു. നിങ്ങളുടെ കോഡ് മുൻനിര സേവനങ്ങളുമായി കർശനമായി ബന്ധിപ്പിച്ചിട്ടില്ലെങ്കിൽ, അവയ്ക്കിടയിൽ വേഗത്തിൽ മാറാൻ കഴിയുമ്പോൾ ഘടകങ്ങളുടെ വഴക്കവും മാറ്റിസ്ഥാപിക്കാവുന്നതുമാണ്. കൂടാതെ, അടുത്ത ഘടകം ചട്ടക്കൂടും ആപ്ലിക്കേഷൻ കോഡും കാര്യക്ഷമമായി സംഘടിപ്പിക്കുന്നതിനുള്ള മികച്ച ജോലി ചെയ്യുന്നു.

ബൺ \ കോർ \ കണ്ടെയ്നർ

കണ്ടെയ്നർ - എൻ്റെ പ്രിയപ്പെട്ട പ്രോഗ്രാമിംഗ് പാറ്റേണുകളിൽ ഒന്ന് നടപ്പിലാക്കുന്നു - ഡിപൻഡൻസി ഇഞ്ചക്ഷൻ. എല്ലാത്തിലും ആശ്രിതത്വ കുത്തിവയ്പ്പ് നല്ലതാണ് - ആപ്ലിക്കേഷൻ്റെ ഭാഗങ്ങൾ നിർദ്ദിഷ്ട ഘടകങ്ങളെ ദുർബലമായി ആശ്രയിച്ചിരിക്കുന്നു, വ്യക്തിഗത ക്ലാസുകൾ അവയുടെ ഡിപൻഡൻസികൾ മാറ്റിസ്ഥാപിച്ച് പരിശോധിക്കാൻ എളുപ്പമാണ്. നിരവധി സേവനങ്ങളിൽ ഇതര നടപ്പാക്കലുകൾ നടപ്പിലാക്കുന്നത് സൗകര്യപ്രദമാണ്, തുടർന്ന് ആപ്ലിക്കേഷൻ കോഡിൽ മാറ്റമില്ലാതെ അവയ്ക്കിടയിൽ എളുപ്പത്തിൽ മാറുക. കൂടാതെ, ഡിപൻഡൻസി ഇഞ്ചക്ഷൻ ഉപയോഗിക്കുന്ന നിങ്ങളുടെ ക്ലാസുകൾ അവയുടെ ഡിപൻഡൻസികൾ വ്യക്തമായി കാണിക്കുന്നു - നിങ്ങളുടെ ആപ്ലിക്കേഷൻ ഘടകങ്ങളുടെ ഒരു ഡിപൻഡൻസി ഗ്രാഫ് പോലും നിങ്ങൾക്ക് നിർമ്മിക്കാനാകും.

ആപ്ലിക്കേഷൻ റൺടൈമിൽ ഈ സേവനങ്ങൾ ആപ്ലിക്കേഷൻ ആക്സസ് ചെയ്യുമ്പോൾ കണ്ടെയ്നർ കോൺഫിഗർ ചെയ്ത സേവനങ്ങൾ ആരംഭിക്കുകയും സംഭരിക്കുകയും ചെയ്യുന്നു. ഒരു ക്ലാസിനുള്ളിൽ, ആപ്ലിക്കേഷൻ്റെ എല്ലാ ഭാഗങ്ങളിലും നിങ്ങൾക്ക് നിയന്ത്രണമുണ്ട്.

ഇത് ഇപ്പോൾ കോർ മൊഡ്യൂളിലെ ചട്ടക്കൂടിൻ്റെ അടിസ്ഥാന ഘടകങ്ങൾ പൂർത്തിയാക്കുന്നു. നടപ്പിലാക്കുന്ന സമയത്ത്, കോർ മൊഡ്യൂളിൽ ഇവൻ്റ് മാനേജ്‌മെൻ്റ്, FormBuilder നടപ്പിലാക്കലുകൾ ഉൾപ്പെട്ടേക്കാം. സഹായ ഘടകങ്ങളിൽ, ഒഴിവാക്കലുകൾ ടൈപ്പുചെയ്യുന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്. ബേസ് എക്‌സ്‌പ്‌ഷൻ ക്ലാസ് ബൺ\കോർ\എക്‌സെപ്ഷൻ\എക്‌സെപ്ഷൻ നൽകിയിരിക്കുന്നതിനാൽ ആപ്ലിക്കേഷനിലും ചട്ടക്കൂടിനുള്ളിലും ടൈപ്പ് ചെയ്‌ത മറ്റെല്ലാ ഒഴിവാക്കലുകളും അതിൽ നിന്ന് പാരമ്പര്യമായി ലഭിക്കും. ഇത് ആപ്ലിക്കേഷൻ ലെവലിൽ കേന്ദ്രീകൃത ഒഴിവാക്കൽ തടസ്സം നൽകുകയും ആപ്ലിക്കേഷൻ ക്രാഷിൽ സംഭവിക്കുന്നതിൽ നിന്നും പിടിക്കപ്പെടാത്ത ഒഴിവാക്കലുകൾ തടയുകയും ചെയ്യുന്നു.

ബൺ ഫ്രെയിംവർക്കിൻ്റെ വികസനത്തെക്കുറിച്ചുള്ള കഥയുടെ ഇനിപ്പറയുന്ന ഭാഗങ്ങളിൽ, ഞാൻ ആപ്ലിക്കേഷൻ ഘടകത്തെക്കുറിച്ച് സംസാരിക്കാൻ തുടങ്ങും, കൂടാതെ PSR0 സ്റ്റാൻഡേർഡ് അനുസരിച്ച് ഫയലുകൾ ഓട്ടോലോഡ് ചെയ്യുന്നതിൻ്റെ സാരാംശവും വിവരിക്കും. അതിനുശേഷം, ഞാൻ ആപ്ലിക്കേഷൻ കോൺഫിഗറേഷൻ സേവനത്തിൻ്റെയും ഒരു കൂട്ടം Http ഘടകങ്ങളുടെയും വിവരണത്തിലേക്ക് പോകും.

പാറ്റേണുകളിൽ, mvc, രജിസ്ട്രിയിൽ ഞാൻ സംതൃപ്തനാണ്. അഭ്യർത്ഥനകൾക്കായി, ഞാൻ ഒരു ചെറിയ അബ്‌സ്‌ട്രാക്ഷൻ ലെയർ എഴുതി, റൂട്ടിംഗിനായി - എൻ്റെ സ്വന്തം അഭ്യർത്ഥന പാഴ്‌സിംഗ് ഫംഗ്‌ഷൻ.
വെബ് ആപ്ലിക്കേഷൻ്റെ ഘടന ഇങ്ങനെയായിരിക്കും

ആപ്ലിക്കേഷൻ ഫോൾഡർ

index.php എന്ന ഇൻപുട്ട് ഫയലിൽ bootstrap.php ഉൾപ്പെടുന്നു. അതാകട്ടെ, കേർണൽ, ഒരു കോൺഫിഗറേഷൻ ഫയൽ, ചില ലൈബ്രറികൾ എന്നിവയെ ബന്ധിപ്പിച്ച് റൂട്ടർ ആരംഭിക്കുന്നു.

കോർ\റൂട്ട് ഉപയോഗിക്കുക; ആവശ്യം_ഒന്ന് "lib/registry.php"; ആവശ്യം_ഒരിക്കൽ "config.php"; ആവശ്യം_ഒന്ന് "lib/datebase.php"; ആവശ്യം_ഒന്ന് "കോർ/മോഡൽ.പിഎച്ച്പി"; ആവശ്യം_ഒന്ന് "കോർ/വ്യൂ.പിഎച്ച്പി"; ആവശ്യം_ഒന്ന് "core/controller.php"; ആവശ്യം_ഒരിക്കൽ "core/route.php"; $ റൂട്ടർ = പുതിയ റൂട്ട്(); $ റൂട്ടർ->ആരംഭിക്കുക(); //റൂട്ടർ ആരംഭിക്കുക

രജിസ്ട്രി ലളിതമാണ്:

നെയിംസ്പേസ് ലിബ്; ക്ലാസ് Lib_Registry (സ്റ്റാറ്റിക് പ്രൈവറ്റ് $ഡാറ്റ = അറേ(); സ്റ്റാറ്റിക് പബ്ലിക് ഫംഗ്‌ഷൻ സെറ്റ് ($കീ, $മൂല്യം) (സ്വയം::$data[$key] = $value; ) സ്റ്റാറ്റിക് പബ്ലിക് ഫംഗ്‌ഷൻ നേടുക($കീ) (റിട്ടേൺ isset(self::$data[$key]) സജ്ജമാക്കാത്തത് (സ്വയം::$data[$key]);

ആഗോള മൂല്യങ്ങൾ സംഭരിക്കുന്നതിനുള്ള ഗെറ്ററുകളും സെറ്ററുകളും ഇതാ.

Lib\Lib_Registry ഉപയോഗിക്കുക; നിർവ്വചിക്കുക("PATH_SITE", $_SERVER["DOCUMENT_ROOT"]); നിർവ്വചിക്കുക("HOST", "localhost"); നിർവ്വചിക്കുക("USER", "റൂട്ട്"); നിർവ്വചിക്കുക("പാസ്‌വേഡ്", "മൈപാസ്"); നിർവ്വചിക്കുക("NAME_BD", "ലേഖനങ്ങൾ"); നിർവ്വചിക്കുക("DS", DIRECTORY_SEPARATOR); $mysqli = പുതിയ mysqli(HOST, USER, PASSWORD,NAME_BD)അല്ലെങ്കിൽ മരിക്കുക("ഡാറ്റാബേസിലേക്ക് ഒരു കണക്ഷൻ സ്ഥാപിക്കാൻ കഴിയുന്നില്ല."$mysqli->connect_errno()); Lib_Registry ::set("mysqli",$mysqli); $mysqli->query("SET പേരുകൾ "utf8""); //ബേസ് ഡാറ്റാബേസിൽ ഡാറ്റ എൻകോഡിംഗ് സജ്ജമാക്കുക

http://domen.ru/articles/index പോലുള്ള ഒരു അഭ്യർത്ഥന ഒരു കൺട്രോളറായി പരിവർത്തനം ചെയ്യപ്പെടുന്നു - ആക്ഷൻ. കൺട്രോളറിൻ്റെയും പ്രവർത്തനത്തിൻ്റെയും പേര് Zend ഫ്രെയിംവർക്ക് ശൈലിയിൽ സജ്ജീകരിച്ചിരിക്കുന്നു, ഒട്ടക കേസ് - Controller_Name, function_name (). കൺട്രോളർ, മോഡൽ, വ്യൂ ഫയൽ എന്നിവ കൺട്രോളർ_ അല്ലെങ്കിൽ മോഡൽ_ പ്രിഫിക്സ് ഇല്ലാതെ ചെറിയ അക്ഷരത്തിലുള്ള കൺട്രോളർ പേരുമായി പൊരുത്തപ്പെടണം

മോഡൽ ക്ലാസ് അതേ രീതിയിൽ വ്യക്തമാക്കിയിരിക്കുന്നു - Model_Name, ഞങ്ങൾ ഇതിനകം തന്നെ വ്യൂ ഫയൽ കണ്ടെത്തി - പ്രവർത്തനത്തിൻ്റെ പേരിലോ വ്യക്തമായി ജനറേറ്റ് (പേര്) രീതിയിലോ

ഭാവിയിൽ ഒരു അഡ്‌മിൻ പാനൽ സൃഷ്‌ടിക്കാൻ ഞങ്ങൾ പദ്ധതിയിടുന്നതിനാൽ, ഞങ്ങൾ ക്ലയൻ്റ്, അഡ്മിൻ ഫോൾഡറുകൾ സൃഷ്‌ടിക്കും. വഴിയിൽ, ഞങ്ങളുടെ റൂട്ടർ സബ്ഫോൾഡറുകൾ കണക്കിലെടുക്കും, അതായത്. കൺട്രോളറുകളിൽ സബ്ഫോൾഡറുകൾ സൃഷ്‌ടിക്കാനും (ഉദാ. /about/contacts/contacts.php) അതിൻ്റെ പാതയിലൂടെ /about/contacts/ ആക്‌സസ് ചെയ്യാനും സാധിക്കും.
അങ്ങനെ ഞങ്ങൾ റൂട്ടർ ആരംഭിച്ചു

/** * */ പബ്ലിക് ഫംഗ്‌ഷൻ ആരംഭം() ( // ($this->getIsAjaxRequest()) ( ) session_start(); $this->dispatch(); ) /** * */ പൊതു പ്രവർത്തനം എങ്കിൽ AJAX അഭ്യർത്ഥന പിടിക്കുക ഡിസ്പാച്ച്())( // കൺട്രോളറിൻ്റെ പേരും പ്രവർത്തനവും ആർഗ്യുമെൻ്റുകളും $this->getDirections($file, $controller, $action, $args) എന്നിവയുമായി പൊരുത്തപ്പെടുന്ന ഒരു ഫയൽ ഡിസ്പാച്ചർക്ക് ലഭിക്കുന്നു; /* ******* ***** * കൺട്രോളർ ഉൾപ്പെടുന്നു - മോഡൽ */ if (is_readable($file) == false) ("ഫയൽ $ഫയൽ 404 കണ്ടെത്തിയില്ല"); // കൺട്രോളർ ഉൾപ്പെടുന്നു ($മോഡൽ =); str_replace("കൺട്രോളർ" , "മോഡൽ", $ഫയൽ); _* ) എങ്കിൽ (is_callable(array($controller, $action)) == false) ("ആക്ഷൻ $ആക്ഷൻ 404 കണ്ടെത്തിയില്ല"); // ആക്ഷൻ $controller->$action($args)

ഡിസ്പാച്ചർ getDirections() രീതിയെ വിളിക്കുന്നു, അതായത്. അഭ്യർത്ഥന നിർദ്ദേശങ്ങൾ നേടുക. സ്ഥിരസ്ഥിതിയായി, ഡിഫോൾട്ട് കൺട്രോളർ ലേഖനങ്ങളാണ്, പ്രവർത്തനം സൂചികയാണ്.

/** * @param $file * @param $controller * @param $action * @param $args */ private function getDirections(&$file, &$controller, &$action, &$args) ( $route = ( ശൂന്യമായ ($_SERVER["REQUEST_URI"]) ? = $this->പാത; കൺട്രോളർ = "ലേഖനങ്ങൾ"; വേറെ ($ഭാഗങ്ങൾ = പൊട്ടിത്തെറിക്കുക("/", $റൂട്ട്); /* ************** നെയിംസ്പേസ് ********** */ if($parts = = "അഡ്മിൻ") ( $this->namespace = "admin"; array_shift($parts); ) /* ******************* ഫോൾഡറുകളും സബ്ഫോൾഡറുകളും ***** * **/ $fullpath = $this->controller_path_folder = $this->namespace; $ഭാഗങ്ങൾ); തുടരുക;

) if (is_file($fullpath . ".php")) (array_shift($parts); $file = "$fullpath.php"; break; ) ) /* ************* ** കൺട്രോളർ, ആക്ഷൻ, പാരാമുകൾ ******** */ if(!isset($part)) $part = "ലേഖനങ്ങൾ"; $ കൺട്രോളർ = $ ഭാഗം; if(!$file) $file = $fullpath."/$part.php"; $action = array_shift($parts); if(!$action) $action = "action_index"; വേറെ $ആക്ഷൻ = "action_$action"; $args = $parts; ))

അടുത്ത പാഠത്തിൽ ഞങ്ങൾ അടിസ്ഥാന കൺട്രോളർ, മോഡലുകൾ, കാഴ്ചകൾ എന്നിവ സൃഷ്ടിക്കുന്നതും ചോദ്യങ്ങൾ എഴുതുന്നതും നോക്കും.

പാഠം 1 ഫയലുകൾ ഇവിടെയുണ്ട്
https://github.com/vaajnur/create_php_application

മാസ്റ്റർ ബ്രാഞ്ച് ആദ്യ പാഠമായിരിക്കും, തുടർന്ന് ഓരോ പാഠത്തിനും അതേ പേരിൽ ഒരു ശാഖ ഉണ്ടാകും - പാഠം 1, പാഠം2, 3..

അവസാനമായി അപ്ഡേറ്റ് ചെയ്തത്: 11/29/2017

ഘടകങ്ങളിലേക്ക് റൂട്ടുകൾ മാപ്പ് ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്ന ആംഗുലറിന് അതിൻ്റേതായ റൂട്ടിംഗ് സിസ്റ്റം ഉണ്ട്. എന്നാൽ ASP.NET കോറിന് അതിൻ്റേതായ റൂട്ടിംഗ് സിസ്റ്റം ഉണ്ട്, അത് അഭ്യർത്ഥനകൾ പ്രോസസ്സ് ചെയ്യാൻ ഉപയോഗിക്കുന്നു. നമുക്ക് എന്ത് പ്രശ്നങ്ങൾ നേരിടാം? ഉദാഹരണത്തിന്, റൂട്ടിംഗ് ഇതിനകം ഉപയോഗിച്ചിരുന്ന മുൻ വിഷയത്തിൽ നിന്ന് പ്രോജക്റ്റ് എടുക്കാം. ഞങ്ങൾ ആംഗുലർ ആപ്ലിക്കേഷനിലെ ലിങ്കുകൾ പിന്തുടരുകയാണെങ്കിൽ, എല്ലാം ശരിയാകും.

എന്നിരുന്നാലും, ബ്രൗസറിൻ്റെ വിലാസ ബാറിൽ നമുക്ക് ആവശ്യമുള്ള വിലാസം നേരിട്ട് നൽകി ഒരു അഭ്യർത്ഥന അയയ്ക്കുകയാണെങ്കിൽ, അത്തരമൊരു അഭ്യർത്ഥന ശരിയായി പ്രോസസ്സ് ചെയ്യപ്പെടില്ല:

ഞങ്ങൾ ഒരു ലിങ്കിൽ ക്ലിക്കുചെയ്യുമ്പോൾ അല്ലെങ്കിൽ ഒരു കോണീയ ആപ്ലിക്കേഷനിൽ പ്രോഗ്രാമാറ്റിക് ആയി, അനുബന്ധ HTML5 API (Pushstate API) ഉപയോഗിക്കുന്നു, ഇത് ഒരു HTTP അഭ്യർത്ഥന അയയ്‌ക്കാതെ തന്നെ ബ്രൗസറിലെ URL മാറ്റുന്നു. എന്നാൽ ബ്രൗസറിൻ്റെ അഡ്രസ് ബാറിൽ നമ്മൾ റിസോഴ്സ് വിലാസം സ്വമേധയാ നൽകുമ്പോൾ, ബ്രൗസർ ASP.NET കോർ ആപ്ലിക്കേഷനിലേക്ക് ഒരു പുതിയ അഭ്യർത്ഥന അയയ്ക്കുന്നു.

മുകളിലുള്ള ഉദാഹരണത്തിൽ, "ഉൽപ്പന്നം/1" എന്ന അഭ്യർത്ഥന അയച്ചു. എന്നാൽ അത്തരമൊരു അഭ്യർത്ഥന മാപ്പ് ചെയ്യുന്ന ഒരു കൺട്രോളർ പ്രവർത്തനം ഞങ്ങളുടെ പക്കലില്ല. അതിനാൽ സ്വാഭാവികമായും നമുക്ക് ഒരു പിശക് ലഭിക്കും. കൂടാതെ ഞങ്ങൾ അധിക സെർവർ-സൈഡ് കോഡ് ചേർക്കേണ്ടതുണ്ട്, അതുവഴി അത്തരം അഭ്യർത്ഥനകളും ആംഗുലർ ആപ്ലിക്കേഷൻ പ്രോസസ്സ് ചെയ്യും.

ഈ സാഹചര്യത്തിൽ നമുക്ക് എന്തുചെയ്യാൻ കഴിയും? ഇതെല്ലാം വെബ് പേജ് എങ്ങനെ രൂപപ്പെടുന്നു എന്നതിനെ ആശ്രയിച്ചിരിക്കുന്നു. അല്ലെങ്കിൽ ഇത് നേരിട്ട് ഉപയോക്താവിന് നേരിട്ട് അയയ്ക്കുന്ന ഒരു സ്റ്റാറ്റിക് വെബ് പേജാണ്. അല്ലെങ്കിൽ ഇത് Angulr ആപ്ലിക്കേഷൻ്റെ ലോഡിംഗ് കോഡ് നിർവചിച്ചിരിക്കുന്ന ഒരു കാഴ്ചയാണ് (cshtml വിപുലീകരണമുള്ള ഒരു ഫയൽ).

സ്റ്റാറ്റിക് ഫയലുകൾക്കായുള്ള അന്വേഷണങ്ങൾ

മുമ്പത്തെ വിഷയത്തിൽ, പ്രോജക്റ്റിൻ്റെ wwwroot ഫോൾഡറിൽ സ്ഥിതി ചെയ്യുന്ന index.html എന്ന സ്റ്റാറ്റിക് വെബ് പേജിലേക്ക് കോണീയ ആപ്ലിക്കേഷൻ ലോഡ് ചെയ്തു:

ASP.NET കോറിലെ കോണാകൃതി

ഈ സാഹചര്യത്തിൽ, അഭ്യർത്ഥന ഒരു സ്റ്റാറ്റിക് ഫയലിനായി ഉദ്ദേശിച്ചുള്ളതല്ലെങ്കിൽ, കൂടാതെ ഏതെങ്കിലും കൺട്രോളർ പ്രവർത്തനങ്ങൾക്ക് വേണ്ടിയുള്ളതല്ലെങ്കിൽ, അത്തരമൊരു അഭ്യർത്ഥനയ്ക്ക് മറുപടിയായി index.html ഫയൽ അയയ്ക്കും. ഈ സാഹചര്യത്തിൽ, സെർവർ ഭാഗത്ത് നമുക്ക് നിരവധി സമീപനങ്ങൾ ഉപയോഗിക്കാം.

റൺ രീതി

അഭ്യർത്ഥന പ്രോസസ്സിംഗ് പൈപ്പ്ലൈനിൻ്റെ അവസാനം മിഡിൽവെയർ ചേർക്കുക എന്നതാണ് ഏറ്റവും എളുപ്പമുള്ള മാർഗ്ഗം, അത് index.html ഫയൽ അയയ്ക്കും. ഇത് ചെയ്യുന്നതിന്, സ്റ്റാർട്ടപ്പ് ക്ലാസിലെ കോൺഫിഗർ രീതി മാറ്റുക:

പൊതുവായ അസാധുവായ കോൺഫിഗർ (IApplicationBuilder ആപ്പ്, IHostingEnvironment env) (env.IsDevelopment()) (app.UseDeveloperExceptionPage(); app.UseWebpackDevMiddleware(new WebpackDevMiddleware.Appes (Hottleware.) ആപ്പ്; .UseStaticFiles( ); app.UseMvc(); .കോമ്പിനേഷൻ(env.WebRootPath, "index.html"));

അതിനാൽ, ആപ്ലിക്കേഷനിലെ ഉറവിടങ്ങളിലേക്ക് മാപ്പ് ചെയ്യാത്ത എല്ലാ അഭ്യർത്ഥനകൾക്കും, wwwroot/index.html ഫയൽ അയയ്ക്കും.

ഈ സമീപനത്തിൻ്റെ പോരായ്മ, സെർവർ വശത്ത് 404 പിശക് കൈകാര്യം ചെയ്യുന്നത് ഞങ്ങൾക്ക് ബുദ്ധിമുട്ടായിരിക്കും എന്നതാണ്, കാരണം ഞങ്ങൾക്ക് അഭ്യർത്ഥനയുമായി ബന്ധപ്പെട്ട കൺട്രോളറുകളും പ്രവർത്തനങ്ങളും ഇല്ലെങ്കിൽ, ക്ലയൻ്റ് ഭാഗത്താണെങ്കിലും അഭ്യർത്ഥന പ്രോസസ്സ് ചെയ്യും. കോണാകൃതിയിൽ.

കൺട്രോളർ രീതി ഉപയോഗിച്ച് ഒരു ഫയൽ അയയ്ക്കുന്നു

കൺട്രോളർ രീതി ഉപയോഗിച്ച് ഒരു ഫയൽ അയച്ചുകൊണ്ട് സമാനമായ സമീപനം നൽകുന്നു. ഉദാഹരണത്തിന്, കൺട്രോളർ ഫോൾഡറിൽ നിങ്ങളുടെ പ്രോജക്റ്റിൽ ഇനിപ്പറയുന്ന ഹോം കൺട്രോളർ ഉണ്ടെന്ന് പറയാം:

Microsoft.AspNetCore.Mvc ഉപയോഗിക്കുന്നു; System.IO ഉപയോഗിക്കുന്നത്; Microsoft.AspNetCore.Hosting ഉപയോഗിക്കുന്നു; നെയിംസ്പേസ് HelloAngularApp.Controllers (പബ്ലിക് ക്ലാസ് ഹോംകൺട്രോളർ: കൺട്രോളർ (IHostingEnvironment env; public HomeController(IHostingEnvironment env) ( this.env = env; ) public IActionResult Index() (പുതിയ ഫിസിക്കൽഫയൽ റിസൾട്ട്(പാത്ത് "), "ടെക്സ്റ്റ്/html"); ) )

ഈ സാഹചര്യത്തിൽ, ഇൻഡെക്സ് രീതി index.html ഫയൽ അയയ്ക്കുന്നു.

ഈ സാഹചര്യത്തിൽ, സ്റ്റാർട്ടപ്പ് ക്ലാസിൻ്റെ കോൺഫിഗർ രീതി ഇനിപ്പറയുന്ന രീതിയിൽ മാറ്റുക:

പൊതു അസാധുവായ കോൺഫിഗർ (IApplicationBuilder ആപ്പ്, IHostingEnvironment env) (env.IsDevelopment()) (app.UseDeveloperExceptionPage(); app.UseWebpackDevMiddleware(new WebpackDevMiddleware=Options). app.UseStaticFiles (); app.UseMvc(റൂട്ടുകൾ =>

ഈ സാഹചര്യത്തിൽ, MVC ഇൻഫ്രാസ്ട്രക്ചറിനായി രണ്ട് റൂട്ടുകൾ നിർവചിച്ചിരിക്കുന്നു. സാധാരണ കൺട്രോളറുകളിലേക്കും അവരുടെ പ്രവർത്തനങ്ങളിലേക്കും ആദ്യ റൂട്ട് മാപ്പ് ചെയ്യുന്നു. രണ്ടാമത്തെ റൂട്ട് MapSpaFallbackRoute() രീതിയും ഹോം കൺട്രോളറിൻ്റെ ഇൻഡെക്സ് പ്രവർത്തനത്തിലേക്കുള്ള മാപ്പും ഉപയോഗിച്ച് നിർവചിച്ചിരിക്കുന്നു, ഈ സാഹചര്യത്തിൽ ഒരു index.html ഫയൽ ഉപയോക്താവിന് തിരികെ അയയ്ക്കുന്നു.

കൺട്രോളർ പ്രവർത്തനങ്ങൾക്കുള്ള അഭ്യർത്ഥനകൾ

ഒരു സ്റ്റാറ്റിക് html പേജിൽ ഒരു കോണീയ ആപ്ലിക്കേഷൻ്റെ ലോഡിംഗ് ഓപ്ഷണലായി നമുക്ക് നിർവചിക്കാം. അതൊരു പ്രകടനവുമാകാം. ഉദാഹരണത്തിന്, പ്രോജക്റ്റിലെ കാഴ്ചകൾ/ഹോം ഡയറക്‌ടറി നിർവചിച്ച് അതിൽ ഒരു പുതിയ ഫയൽ Index.cshtml സ്ഥാപിക്കാം:

ASP.NET കോറിലെ കോണാകൃതി

ഈ സാഹചര്യത്തിൽ, കാഴ്ചയിൽ html കോഡ് മാത്രമേ അടങ്ങിയിട്ടുള്ളൂ, ആവശ്യമെങ്കിൽ, നിങ്ങൾക്ക് അതിൽ റേസർ നിർദ്ദേശങ്ങൾ നിർവചിക്കാനും അതിനായി ഒരു മാസ്റ്റർ പേജ് സൃഷ്ടിക്കാനും കഴിയും.

കൂടാതെ HomeController's Index രീതി ഈ കാഴ്ച ഉപയോഗിക്കും:

Microsoft.AspNetCore.Mvc ഉപയോഗിക്കുന്നു; നെയിംസ്പേസ് HelloAngularApp.Controllers (പബ്ലിക് ക്ലാസ് ഹോംകൺട്രോളർ: കൺട്രോളർ (പബ്ലിക് IActionResult Index() ( റിട്ടേൺ വ്യൂ(); ) )

സ്റ്റാർട്ടപ്പ് ക്ലാസിൻ്റെ കോൺഫിഗർ രീതിയിൽ, ഞങ്ങൾ ഇനിപ്പറയുന്ന കോഡ് നിർവ്വചിക്കുന്നു:

പൊതുവായ അസാധുവായ കോൺഫിഗർ (IApplicationBuilder ആപ്പ്, IHostingEnvironment env) (env.IsDevelopment()) (app.UseDeveloperExceptionPage(); app.UseWebpackDevMiddleware(new WebpackDevMiddleware.//Options) ); - ഇത് ഈ രീതി ഇനി ആവശ്യമില്ല. റൂട്ടുകൾ.MapSpaFallbackRoute("കോണീയ-ഫാൾബാക്ക്", പുതിയത് (കൺട്രോളർ = "ഹോം", ആക്ഷൻ = "ഇൻഡക്സ്" ) );

ഇവിടെയും, routes.MapSpaFallbackRoute രീതി ഉപയോഗിച്ച്, മറ്റ് ഉറവിടങ്ങളിലേക്ക് മാപ്പ് ചെയ്യാത്ത മറ്റെല്ലാ അഭ്യർത്ഥനകളും HomeController-ൻ്റെ Index രീതി കൈകാര്യം ചെയ്യും.