رﺮﻘﻤﻟ ﻲﻠﻤﻌﻟا ﻞﯿﻟﺪﻟا ﺔﻋزﻮﻤﻟا ﺔﻤﻈﻧﻷا 1479 Distributed Systems

‫اﻟﺪﻟﯿﻞ اﻟﻌﻤﻠﻲ ﻟﻤﻘﺮر‬
‫اﻷﻧﻈﻤﺔ اﻟﻤﻮزﻋﺔ ‪1479‬‬

‫‪Distributed Systems‬‬
‫إﻋﺪاد‪ :‬د‪ .‬م‪ .‬ﺳﺎﻣﺮ ﺣﺴﻨﻲ ﺟﺎﻟﻮدي‬

‫ﺟﺎﻣﻌﺔ اﻟﻘﺪس اﻟﻤﻔﺘﻮﺣﺔ ‪ -‬ﻓﺮع ﻧﺎﺑﻠﺲ‬
‫إﻋداد‪ :‬د‪ .‬م‪ .‬ﺳﺎﻣر ﺣﺳﻧﻲ ﺟﺎﻟودي ‪ -‬ﺟﺎﻣﻌﺔ اﻟﻘدس اﻟﻣﻔﺗوﺣﺔ ‪ -‬ﻓرع ﻧﺎﺑﻠس‪2016 ،‬‬ ‫‪1‬‬
‫ﻣﻘﺪﻣﺔ‬
‫ﻋﺰﯾﺰي اﻟﺪارس‪ ،‬إن ﻓﻠﺴﻔﺔ اﻟﻨﻈﻢ اﻟﻤﻮزﻋﺔ ھﻮ أن ﯾﻜﻮن ﻟﺪﯾﻚ ﺷﺒﻜﺔ ﻣﻦ اﻟﺤﻮاﺳﯿﺐ )اﻟﻌﻘﺪ ‪ (nodes‬اﻟﺘﻲ ﯾﻌﻤﻞ ﺑﻌﺾ ﻣﻨﮭﺎ ﻋﻠﻰ ﻧﻈﺎم‬
‫ﺗﺸﻐﯿﻞ ﻣﺨﺘﻠﻒ ﻋﻦ ﻧﻈﻢ اﻟﺘﺸﻐﯿﻞ ﻋﻠﻰ ﺑﺎﻗﻲ اﻟﻌﻘﺪ )اﻟﺤﻮاﺳﯿﺐ(‪ ،‬وﺗﻄﺒﯿﻘﺎت ﺑﻌﻀﮭﺎ ﻣﻜﺘﻮب ﺑﻠﻐﺔ ﺑﺮﻣﺠﺔ ﻗﺪ ﺗﻜﻮن ﻧﻔﺴﮭﺎ أو ﻣﺨﺘﻠﻔﺔ ﻋﻦ‬
‫ﺑﺎﻗﻲ اﻟﻌﻘﺪ‪ .‬ﻓﻤﺜﻼ‪ ،‬ﺷﺒﻜﺔ ﻣﺎ‪ ،‬ﺗﺤﻮي ﺟﮭﺎز )ﻋﻘﺪة( ﯾﻌﻤﻞ ﺑﻨﻈﺎم ﺗﺸﻐﯿﻞ وﯾﻨﺪوز‪ ،‬ﯾﻌﻤﻞ ﻋﻠﯿﮫ ﺗﻄﺒﯿﻖ ﻣﻜﺘﻮب ﺑﻠﻐﺔ ‪ C#‬وﯾﺮﺗﺒﻂ ﺑﻘﺎﻋﺪة‬
‫ﺑﯿﺎﻧﺎت ﻣﻦ ﻣﺎﯾﻜﺮوﺳﻮﻓﺖ‪ .‬وﺟﮭﺎز آﺧﺮ ﯾﻌﻤﻞ ﺑﺄﺣﺪ أﻧﻈﻤﺔ ﻟﯿﻨﻮﻛﺲ‪ ،‬ﯾﻌﻤﻞ ﻋﻠﯿﮫ ﺗﻄﺒﯿﻖ ﻣﻜﺘﻮب ﺑﻠﻐﺔ ‪ ،Java‬وﯾﺮﺗﺒﻂ ﺑﻘﺎﻋﺪة ﺑﯿﺎﻧﺎت‬
‫‪ .MySQL‬وﺟﮭﺎز ﺛﺎﻟﺚ‪ ،‬اﻟﺦ‪.‬‬
‫ﯾﻮﺟﺪ ﻓﻲ ھﺬه اﻟﺤﺎﻟﺔ اﻟﻌﺪﯾﺪ ﻣﻦ اﻟﻤﻨﺼﺎت ‪ platforms‬اﻟﺘﻲ ﺗﻌﻤﻞ ﺑﻨﻈﻢ ﺗﺸﻐﯿﻞ وﺗﻄﺒﯿﻘﺎت وﻗﻮاﻋﺪ ﺑﯿﺎﻧﺎت ﺗﺨﺘﻠﻒ ﻋﻦ ﺑﻌﻀﮭﺎ اﻟﺒﻌﺾ‪.‬‬
‫ھﻨﺎ ﯾﺄﺗﻲ دور اﻟﻨﻈﻢ اﻟﻤﻮزﻋﺔ ﻓﻲ ﺗﻮﺻﯿﻒ ﺑﺮوﺗﻮﻛﻮل ﯾﻌﻤﻞ ﻋﻠﻰ ﺟﺴﺮ اﻟﮭﻮة ﺑﯿﻦ ھﺬه اﻟﻤﻨﺼﺎت ﻣﻦ ﺧﻼل ﺣﻞ ﻣﺸﻜﻠﺔ اﻟﺘﺒﺎدﻟﯿﺔ‬
‫)‪ (Interoperability‬وﯾﻮﻓﺮ ﻓﻲ ﻧﻔﺲ اﻟﻮﻗﺖ ﺗﻘﻨﯿﺔ اﻻﺗﺼﺎل ﺑﯿﻨﮭﺎ‪.‬‬
‫ﻓﻲ ھﺬا اﻟﺪﻟﯿﻞ اﻟﻌﻤﻠﻲ‪ ،‬ﺳﺘﻌﻤﻞ ﻋﺰﯾﺰي اﻟﺪارس‪ ،‬وﺑﻤﺴﺎﻋﺪة ﻣﺸﺮﻓﻚ اﻷﻛﺎدﯾﻤﻲ وﻓﻨﻲ اﻟﻤﺨﺘﺒﺮ‪ ،‬ﻋﻠﻰ إﺟﺮاء ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﺘﺠﺎرب‬
‫اﻟﻌﻤﻠﯿﺔ‪ ،‬ﻣﻦ ﺧﻼل ﻧﺸﺎطﺎت ﺻﻔﯿّﺔ‪ .‬ﺣﯿﺚ ﺳﺘﻘﻮم ﺑﺘﺠﺎرب ﺗﺪﻋﻢ ﺗﻄﺒﯿﻘﺎت اﻟﻨﻈﻢ اﻟﻤﻮزﻋﺔ ﺑﺎﺳﺘﺨﺪام ﻟﻐﺔ ﺟﺎﻓﺎ‪ ،‬ﻣﻦ ﺧﻼل ﺑﺮوﺗﻮﻛﻮﻟ ّﻲ‬
‫اﻻﺗﺼﺎل ‪ RMI‬و ‪ .CORBA‬وﺳﺘﻌﻤﻞ أﯾﻀﺎ ﻋﻠﻰ إﺟﺮاء ﺗﺠﺎرب ﺗﺪﻋﻢ اﻛﺒﺮ ﺷﺒﻜﺔ ﻣﻮزﻋﺔ وھﻲ اﻻﻧﺘﺮﻧﺖ‪ .‬ﺑﺎﻟﺘﺎﻟﻲ ﺳﺘﺴﺘﺨﺪم ﻛﻞ ﻣﻦ‬
‫ﻟﻐﺔ ‪ PHP‬وﺑﺮوﺗﻮﻛﻮل اﻻﺗﺼﺎل ‪.XML-RPC‬‬
‫ﻗﻮاﻋﺪ اﻟﺒﯿﺎﻧﺎت اﻟﺘﻲ ﺳﺘﺴﺘﺨﺪم ﻓﻲ ﺟﻤﯿﻊ اﻟﺤﺎﻻت‪ ،‬ﺳﻮاء ﻛﺎﻧﺖ ﺗﻄﺒﯿﻘﺎت ﻋﺎدﯾﺔ أو ﺗﻄﺒﯿﻘﺎت اﻻﻧﺘﺮﻧﺖ‪ ،‬ھﻲ ‪ .MySQL‬وﺑﺎﻟﺘﺎﻟﻲ ﻓﺈن‬
‫ﺗﻄﺒﯿﻘﺎت اﻟﻨﻈﻢ اﻟﻤﻮزﻋﺔ وﻗﻮاﻋﺪ ﺑﯿﺎﻧﺎﺗﮭﺎ ﺳﺘﻜﻮن اﻟﮭﺪف اﻷﺳﺎﺳﻲ ﻣﻦ ھﺬا اﻟﺪﻟﯿﻞ‪.‬‬
‫اﻟﻨﺸﺎط اﻟﺼﻔﻲ اﻷول‬
‫اﺳﺘﺪﻋﺎء اﻟﻄﺮق ﻋﻦ ﺑﻌﺪ‬

‫‪Remote Method Invocation‬‬
‫أوﻻ‪ :‬ﻣﻘﺪﻣﺔ‬
‫ﺗﺪﻋﻢ ﻟﻐﺔ ﺟﺎﻓﺎ اﻟﻌﺪﯾﺪ ﻣﻦ ﺑﺮوﺗﻮﻛﻮﻻت اﻻﺗﺼﺎﻻت اﻟﺘﻲ ﺗﻌﺘﻤﺪ ﻋﻠﻰ طﺒﻘﺔ اﻟﺸﺒﻜﺔ‪ ،‬وﺗﻌﺘﺒﺮ ھﺬه اﻟﺒﺮوﺗﻮﻛﻮﻻت ﺣﻠﻘﺔ اﻟﻮﺻﻞ ﻣﺎ ﺑﯿﻦ‬
‫اﻟﺘﻄﺒﯿﻘﺎت اﻟﺒﺮﻣﺠﯿﺔ وﻗﻮاﻋﺪ اﻟﺒﯿﺎﻧﺎت واﻟﻤﺴﺘﺨﺪم ﻣﻦ ﺟﮭﺔ وﻣﺎ ﺑﯿﻦ ﺑﺮﺗﻮﻛﻮﻻت اﻻﺗﺼﺎل ﻓﻲ طﺒﻘﺔ اﻟﺸﺒﻜﺔ‪ .‬إﺣﺪى ھﺬه اﻟﺒﺮوﺗﻮﻛﻮﻻت‬
‫اﻟﺘﻲ ﺗﺪﻋﻤﮭﺎ ﺟﺎﻓﺎ ھﻲ اﺳﺘﺪﻋﺎء اﻟﻄﺮق ﻋﻦ ﺑﻌﺪ ‪ ،Remote Method Invocation‬واﻟﺘﻲ ﺗﻌﺘﺒﺮ ورﯾﺜﺔ ﺑﺮوﺗﻮﻛﻮل اﺳﺘﺪﻋﺎء اﻹﺟﺮاء‬
‫ﻋﻦ ﺑﻌﺪ ‪ ،Remote Procedure Call‬إﻻ أن ﻟﻐﺔ ﺟﺎﻓﺎ‪ ،‬ﺗﻌﺮف طﺮق ‪ methods‬ﺑﺪﻻ ﻣﻦ اﻹﺟﺮاءات ‪ procedures‬أو اﻟﺪوال‬
‫‪ .functions‬أﯾﻀﺎ ﺗﺪﻋﻢ ﻟﻐﺔ ﺟﺎﻓﺎ ﻣﻌﻤﺎرﯾﺔ وﺳﯿﻂ طﻠﺐ اﻷھﺪاف اﻟﻤﺸﺘﺮﻛﺔ ‪Common Object Request Broker‬‬
‫‪ Architecture‬أو اﻟﻤﻌﺮوﻓﺔ ﺑﺎﻻﺧﺘﺼﺎر ‪ .CORBA‬ﺗﻘﺪم ﻟﻐﺔ ﺟﺎﻓﺎ ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﻤﻜﺘﺒﺎت اﻟﺘﻲ ﺗﯿ ّﺴﺮ ﻋﻤﻞ اﻟﻤﺒﺮﻣﺞ ﺑﺤﯿﺚ ﯾﻤﻜﻦ‬
‫ﻛﺘﺎﺑﺔ ﺑﺮاﻣﺞ ﺗﻌﻤﻞ ﻋﻠﻰ اﻻﺗﺼﺎل ﺑﯿﻦ اﻟﺤﻮاﺳﯿﺐ ﺑﺎﺳﺘﺨﺪام ‪ CORBA‬أو ‪ RMI‬وﻓﻲ ﻧﻔﺲ اﻟﻮﻗﺖ اﻟﺮﺑﻂ ﻣﻊ ﻗﻮاﻋﺪ اﻟﺒﯿﺎﻧﺎت‪ ،‬أو إﻧﺸﺎء‬
‫‪ GUI‬ﺧﺎص ﺑﺎﻟﻤﺴﺘﺨﺪﻣﯿﻦ‪ .‬ھﺬه اﻟﺘﺠﺮﺑﺔ‪ ،‬ﺳﯿﺘﻢ اﻟﺘﻌﺎﻣﻞ ﻣﻊ ‪ ،RMI‬وﻓﻲ اﻟﺘﺠﺮﺑﺔ اﻟﺜﺎﻧﯿﺔ ﺳﯿﺘﻢ اﻟﺘﻌﺎﻣﻞ ﻣﻊ ‪.CORBA‬‬
‫ﻋﺰﯾﺰي اﻟﺪارس‪ ،‬ھﻨﺎك ﻋﺪة طﺮق ﻟﺘﺼﻨﯿﻒ )‪ (Compile‬وﺗﻨﻔﯿﺬ )‪ (Run‬ﺑﺮاﻣﺞ ﺟﺎﻓﺎ‪ .‬ﻣﻨﮭﺎ‪:‬‬
‫ﺑﺎﺳﺘﺨﺪام ﺑﯿﺌﺔ اﻟﺘﻄﻮﯾﺮ )‪ (eclipse‬واﻟﺬي ﯾﻤﻜﻦ ﺗﺤﻤﯿﻠﮫ )‪ (download‬ﻣﻦ اﻟﻤﻮﻗﻊ اﻟﺘﺎﻟﻲ‪:‬‬ ‫‪.1‬‬
‫‪http://www.eclipse.org/downloads/‬‬
‫ﺑﺎﺳﺘﺨﺪام ﺑﯿﺌﺔ اﻟﺘﻄﻮﯾﺮ )‪ ،(JBuilder‬وﻟﻜﻦ ﻧﺴﺨﺔ ﺗﺠﺮﯾﺒﯿﺔ‪ ،‬واﻟﺬي ﯾﻤﻜﻦ ﺗﺤﻤﯿﻠﮫ ﻣﻦ اﻟﻤﻮﻗﻊ اﻟﺘﺎﻟﻲ‪:‬‬ ‫‪.2‬‬
‫‪https://downloads.embarcadero.com/free/jbuilder‬‬
‫ﺑﺎﺳﺘﺨﺪام ﺑﯿﺌﺔ اﻟﺘﻄﻮﯾﺮ )‪ ،(JCreator‬واﻟﺬي ﯾﻤﻜﻦ ﺗﺤﻤﯿﻠﮫ ﻣﻦ اﻟﻤﻮﻗﻊ اﻟﺘﺎﻟﻲ‪http://www.jcreator.com/ :‬‬ ‫‪.3‬‬
‫ﺑﺎﺳﺘﺨﺪام ﺑﯿﺌﺔ اﻟﺘﻄﻮﯾﺮ )‪ (NetBeans‬واﻟﺬي ﯾﻤﻜﻦ ﺗﺤﻤﯿﻠﮫ ﻣﻦ اﻟﻤﻮﻗﻊ اﻟﺘﺎﻟﻲ‪https://netbeans.org/downloads/ :‬‬ ‫‪.4‬‬
‫ﺑﺎﺳﺘﺨﺪام ﻣﻮﻗﻊ ﺷﺮﻛﺔ أوراﻛﻞ )‪ ،(Oracle‬ﯾﻤﻜﻦ ﺗﺤﻤﯿﻞ ﻣﻌﺪات ﺗﻄﻮﯾﺮ ﺟﺎﻓﺎ )‪: (download JDK‬‬ ‫‪.5‬‬
‫‪ http://www.oracle.com/technetwork/java/javase/downloads/index.html‬وﻣﻦ ﺛﻢ ﺑﻌﺪ ذﻟﻚ ﯾﻤﻜﻦ اﻟﻌﻤﻞ‬
‫ﻋﻠﻰ ﺑﯿﺌﺔ ‪ JDK‬ﺑﺸﻜﻞ ﻣﺒﺎﺷﺮ أو ﻣﻦ ﺧﻼل ﺑﺮﻧﺎﻣﺞ )‪ (Textpad‬ﻟﻠﺘﺴﮭﯿﻞ أﺛﻨﺎء اﻟﺘﺼﻨﯿﻒ واﻟﺘﻨﻔﯿﺬ ﻣﻦ اﻟﻤﻮﻗﻊ‪:‬‬
‫‪http://www.textpad.com/download/‬‬
‫ﺳﯿﺘﻢ اﻋﺘﻤﺎد اﻟﻄﺮﯾﻘﺔ اﻷﺧﯿﺮة ﻟﺘﻨﻔﯿﺬ اﻟﺘﺠﺮﺑﺘﯿﻦ اﻷوﻟﻰ واﻟﺜﺎﻧﯿﺔ ﻣﻦ ھﺬا اﻟﺪﻟﯿﻞ اﻟﻌﻤﻠﻲ وذﻟﻚ ﻟﻐﺎﯾﺎت ﺗﺤﻘﯿﻖ اﻷھﺪاف اﻟﻤﺮﺟﻮة ﻣﻦ اﻟﻤﻘﺮر‪.‬‬
‫ﻣﻊ اﻟﻌﻠﻢ أﻧﮫ ﺑﺈﻣﻜﺎﻧﻚ اﺳﺘﺨﺪام أي واﺟﮭﺔ ﺗﻄﻮﯾﺮ أﺧﺮى )‪ (IDE‬ﺗﻨﺎﺳﺒﻚ‪ ،‬وذﻟﻚ ﺑﺎﻟﺘﻨﺴﯿﻖ ﻣﻊ ﻣﺸﺮﻓﻚ اﻷﻛﺎدﯾﻤﻲ‪ .‬ﻓﻲ اﻟﺘﺠﺮﺑﺔ اﻷﺧﯿﺮة‪،‬‬
‫ﺳﯿﺘﻢ اﺳﺘﺨﺪام ﺑﯿﺌﺔ اﻟﺘﻄﻮﯾﺮ اﻟﻤﺘﻜﺎﻣﻠﺔ ‪ ،NetBeans IDE‬ﺣﯿﺚ ﺳﺘﻘﻮم‪ ،‬ﻋﺰﯾﺰي اﻟﺪارس‪ ،‬ﺑﺮﺑﻂ ﻗﺎﻋﺪة اﻟﺒﯿﺎﻧﺎت ﻣﻊ ﺧﺎدم ﺗﻘﻨﯿﺎت‬
‫اﻻﺗﺼﺎل ﻓﻲ ﺟﺎﻓﺎ‪.‬‬
‫ﺛﺎﻧﯿﺎ‪ :‬اﻷھﺪاف‬
‫أن ﺗﺘﻌﺮف ﻋﻠﻰ آﻟﯿﺔ ﻋﻤﻞ إﺣﺪى ﺗﻘﻨﯿﺎت اﻻﺗﺼﺎل ﻓﻲ ﺟﺎﻓﺎ واﻟﺘﻲ ﺗﺴﻤﻰ "اﺳﺘﺪﻋﺎء اﻟﻄﺮق ﻋﻦ ﺑﻌﺪ" ‪.RMI‬‬ ‫‪.1‬‬
‫أن ﺗﻌﺮف دور ﻛﻞ ﻣﻦ ‪ stub‬و ‪ skeleton‬و ‪ Registry‬ﻓﻲ ﺗﻘﻨﯿﺔ اﻻﺗﺼﺎل ‪.RMI‬‬ ‫‪.2‬‬
‫أن ﺗﺘﻌﺮف ﻛﯿﻔﯿﺔ ﺑﺮﻣﺠﺔ واﺳﺘﺨﺪام ﺗﻘﻨﯿﺔ اﻻﺗﺼﺎل ﻋﻦ ﺑﻌﺪ ﺑﺎﺳﺘﺨﺪام ﺑﺮوﺗﻮﻛﻮل ‪ ،RMI‬واﺳﺘﺤﻀﺎر اﻟﻄﺮق ﻋﻦ ﺑﻌﺪ‪.‬‬ ‫‪.3‬‬
‫أن ﺗﺤﺪد ﻣﺸﻜﻠﺔ ﺗﻘﻨﯿﺔ اﻻﺗﺼﺎل ‪ RMI‬اﻟﺮﺋﯿﺴﯿﺔ‪ ،‬واﻟﺘﻲ ﺗﻌﺪ إﺣﺪى ﻣﺴﺎوئ ‪.RMI‬‬ ‫‪.4‬‬
‫ﺛﺎﻟﺜﺎ‪ :‬ﺧﻄﻮات ﻋﻤﻞ اﻟﺘﺠﺮﺑﺔ‬

‫ﻧﺒﺪأ ﺑﺸﺮح ﻓﻠﺴﻔﺔ ﺑﺮوﺗﻮﻛﻮل اﻻﺗﺼﺎل ‪ .RMI‬ﺣﯿﺚ ﯾﻌﻤﻞ ھﺬا اﻟﺒﺮوﺗﻮﻛﻮل ﺑﯿﻦ طﺒﻘﺔ اﻟﻨﻘﻞ ‪ transport layer‬وطﺒﻘﺔ اﻟﺘﻄﺒﯿﻘﺎت‪ ،‬ﻛﻤﺎ‬
‫ھﻮ ﻣﻮﺿﺢ ﻓﻲ اﻟﺼﻮرة أدﻧﺎه‪ .‬ﻓﯿﻜﺘﺐ اﻟﻤﺒﺮﻣﺞ ﺑﺮﻧﺎﻣﺠﺎ ﺑﻠﻐﺔ ﺟﺎﻓﺎ ﻟﻜﻞ ﻣﻦ اﻟﺨﺎدم ‪ server‬واﻟﺰﺑﻮن ‪ ،client‬ﻓﻲ طﺒﻘﺔ اﻟﺘﻄﺒﯿﻘﺎت‬
‫‪ ،application layer‬ﺛﻢ ﯾﺘﻢ اﺳﺘﺨﺪام ﺑﺮوﺗﻮﻛﻮل ‪ RMI‬ﻣﻦ أﺟﻞ إﻧﺸﺎء اﺗﺼﺎﻻ ﺑﯿﻦ اﻟﺨﺎدم واﻟﺰﺑﻮن‪ .‬ﺗﻌﻤﻞ ﺗﻘﻨﯿﺔ اﻻﺗﺼﺎل ‪ RMI‬ﻓﻲ‬
‫طﺒﻘﺔ اﻟﺸﺒﻜﺔ ﺣﯿﺚ ﺗﺴﺘﺨﺪم ﺑﺮوﺗﻮﻛﻮل ‪ ،TCP‬ﻟﺘﺒﺎدل اﻟﺒﯿﺎﻧﺎت ﺑﯿﻦ اﻟﺨﺎدم واﻟﺰﺑﻮن ﺑﺎﺳﺘﺨﺪام ﺷﺒﻜﺔ ‪ LAN/WAN‬ﺗﻌﻤﻞ ﻋﻠﻰ ﺣﺰﻣﺔ‬
‫ﺑﺮوﺗﻮﻛﻮﻻت اﻻﻧﺘﺮﻧﺖ وھﻲ ﺣﺰﻣﺔ ‪.TCP/IP‬‬
‫آﻟﯿﺔ إﻧﺸﺎء اﻻﺗﺼﺎل وﺗﺒﺎدل اﻟﺒﯿﺎﻧﺎت ﻣﻮﺿﺤﺔ ﻓﻲ اﻟﺼﻮرة أدﻧﺎه‪ .‬ﯾﺒﺪأ اﻟﺨﺎدم ﻛﺨﻄﻮة أوﻟﻰ ﺑﺘﺴﺠﯿﻞ ﻣﻨﮭﺎﺟﮫ )طﺮﯾﻘﺘﮫ ‪ ،(method‬وھﻮ‬
‫اﻟﻤﻨﮭﺎج اﻟﺬي ﺳﯿﺘﻢ ﻣﻨﺎداﺗﮫ ﻣﻦ ﻗﺒﻞ اﻟﺰﺑﺎﺋﻦ‪ ،‬ﻓﻲ داﺧﻞ ﺳ ِﱢﺠﻞ ‪ ،Registry‬ﺧﺎص ﺑﻨﻈﺎم ‪ RMI‬واﻟﺬي ﻗﺪ ﯾﺘﻮاﺟﺪ ﻋﻠﻰ ﺟﮭﺎز آﺧﺮ طﺒﻌﺎ‪.‬‬
‫ﺑﻌﺪ ذﻟﻚ وﻋﻨﺪﻣﺎ ﯾﺮﯾﺪ اﻟﺰﺑﻮن ‪ ،client‬وﻛﺨﻄﻮة ﺛﺎﻧﯿﺔ‪ ،‬ﺑﺎﻟﺒﺤﺚ ﻋﻦ اﻟﻤﻨﮭﺎج‪ ،‬ﯾﺒﺪأ ﺑﺎﻟﺒﺤﺚ ﻋﻨﮭﺎ ﻓﻲ اﻟﺴﺠﻞ ‪ ،Registry‬ﻓﺘﻌﯿﺪ ﻟﮫ أرْ ِو َﻣﺔ‬
‫)ﻋﻘﺐ( اﻟﺨﺎدم ‪ ،server stub‬واﻟﺘﻲ ﺗﻜﻮن ﻣﻦ ﺟﮭﺔ اﻟﺰﺑﻮن‪ .‬ﻓﻤﻦ ﺧﻼﻟﮭﺎ ﯾﻤﻜﻦ ﻟﻠﺰﺑﻮن وﻛﺨﻄﻮة راﺑﻌﺔ اﻻﺗﺼﺎل ﻣﻊ ﻣﻔﺘﺎح ھﯿﻜﻠﻲ‬
‫)‪ (skeleton‬ﺟﮭﺔ اﻟﺨﺎدم ﻟﺘﺒﺎدل اﻟﺒﯿﺎﻧﺎت‪.‬‬
‫‪https://camo.githubusercontent.com/fe96bc186fc00c31f975b687697565fc71343635/687474703a2f2f6c79636f672e636f6d2f77702d636f6e74656e742f75706c6f6164732f323031312f30332f6a6176612d726d692d6f766572766965772e706e67‬‬
‫ﯾﺘﺒﯿﻦ ﻋﺰﯾﺰي اﻟﺪارس‪ ،‬أﻧﻨﺎ ﺑﺤﺎﺟﺔ إﻟﻰ ﺛﻼﺛﺔ ﺑﺮاﻣﺞ‪ ،‬ﺑﺮﻧﺎﻣﺞ اﻟﻮاﺟﮭﺔ ‪ ،remote interface‬وﯾﺠﺐ أن ﺗﺤﻤﻞ اﻻﺳﻢ اﻟﺬي ﺳﯿﺘﻢ ﻣﻨﺎداﺗﮫ‪.‬‬
‫وﺑﺮﻧﺎﻣﺞ ﺛﺎﻧﻲ ﺧﺎص ﺑﺎﻟﺨﺎدم ‪ .remote server‬وﺑﺮﻧﺎﻣﺞ ﺛﺎﻟﺚ ﺑﺴﯿﻂ ﯾﻤﺜﻞ اﻟﺰﺑﻮن ‪ .client‬ﻧﺒﺪأ ﺑﺎﻟﮭﺪﻓﯿﻦ اﻷول واﻟﺜﺎﻧﻲ واﻟﻠﺬﯾﻦ ﯾﻤﻜﻦ‬
‫ﺗﺤﻘﯿﻘﮭﻤﺎ ﻣﻦ ﺧﻼل اﻟﺒﺮاﻣﺞ اﻟﺘﺎﻟﯿﺔ‪ .‬أﻛﺘﺐ ﻛﻞ ﺑﺮﻧﺎﻣﺞ ﻣﻦ اﻟﺒﺮاﻣﺞ اﻟﺘﺎﻟﯿﺔ ﻓﻲ ﻣﻠﻒ ﻣﻨﻔﺼﻞ إﻣﺎ ﺑﺎﺳﻢ اﻟﺼﻨﻒ أو ﺑﺎﺳﻢ اﻟﻮاﺟﮭﺔ‪.‬‬
‫اﻟﻤﻠﻒ اﻷول ‪Hello.java‬‬
‫ﯾﺠﺐ اﺳﺘﺤﻀﺎر ﻣﻜﺘﺒﺔ ‪ RMI‬ﻛﻤﺎ ﯾﻠﻲ ;*‪ import java.rmi.‬أو ﺗﻔﺼﯿﻞ اﻷﺟﺰاء اﻟﺘﻲ ﻧﺮﯾﺪھﺎ ﻣﻦ ﺗﻠﻚ اﻟﻤﻜﺘﺒﺔ ﻛﻤﺎ ھﻮ ﻣﻮﺿﺢ ﻓﻲ‬
‫اﻟﺒﺮﻧﺎﻣﺞ أدﻧﺎه‪ .‬ﺣﯿﺚ ﻧﻌﺮف واﺟﮭﺔ ‪ ،Hello‬واﻟﺘﻲ ﺗﻌﺮف ﺑﺪورھﺎ اﻟﻤﻨﮭﺞ اﻟﺬي ﺳﯿﺘﻢ اﺳﺘﺤﻀﺎره ﻋﻦ ﺑﻌﺪ‪.‬‬
‫;‪import java.rmi.Remote‬‬
‫;‪import java.rmi.RemoteException‬‬
‫‪public interface Hello extends Remote‬‬

‫{‬
‫;‪String sayHello() throws RemoteException‬‬
‫}‬
‫اﻟﻤﻠﻒ اﻟﺜﺎﻧﻲ ‪Server.java‬‬
‫ﻟﻜﺘﺎﺑﺔ ﺑﺮﻧﺎﻣﺞ اﻟﺨﺎدم‪ ،‬ﻧﺘﺒﻊ اﻟﺨﻄﻮات اﻟﺘﺎﻟﯿﺔ‪:‬‬
‫ وﻋﻠﯿﮫ ﯾﺠﺐ ﺗﻌﺮﯾﻒ اﻟﻤﻨﮭﺞ )اﻟﻄﺮﯾﻘﺔ( اﻟﺘﻲ ﺳﯿﻘﻮم اﻟﺰﺑﻮن ﺑﻤﻨﺎداﺗﮭﺎ ﻟﻠﺘﻨﻔﯿﺬ وھﻲ‬،Hello ‫ﯾﻘﻮم اﻟﺨﺎدم ﺑﺘﻨﻔﯿﺬ اﻟﻮاﺟﮭﺔ‬ •
.sayHello()
.obj ‫ﯾﺠﺐ ﻋﻤﻞ ﻣﺜﯿﻞ ﻣﻦ اﻟﺨﺎدم وﻟﯿﻜﻦ ﺑﺈﺳﻢ‬ •
‫ ﻟﺬﻟﻚ‬.‫ وﻟﻜﻦ ﯾﻤﻜﻦ اﻹﺷﺎرة إﻟﻰ ھﺪف ﯾﻨﻔﺬ اﻟﻮاﺟﮭﺔ ﺑﺎﻟﺘﺤﻮﯾﻞ إﻟﻰ ﻧﻮع اﻟﻮاﺟﮭﺔ‬،‫ﻻ ﯾﻤﻜﻦ ﻋﻤﻞ ﻣﺜﯿﻞ ﻣﻦ واﺟﮭﺔ ﻓﻲ ﻟﻐﺔ ﺟﺎﻓﺎ‬ •
‫ إﻟﻰ ﻧﻔﺲ ﻧﻮع‬exportObject ‫ ﺑﺤﯿﺚ ﺗﻌﻤﻞ ﻋﻠﻰ ﺗﺤﻮﯾﻞ ﻧﻮع ﻧﺎﺗﺞ ﺗﻨﻔﯿﺬ اﻟﻤﻨﮭﺞ‬،stub ‫ وﻟﯿﻜﻦ ﺑﺈﺳﻢ‬Hello ‫أﻧﺸﺊ ﻋﻘِﺐ ﻣﻦ‬
.‫اﻟﻮاﺟﮭﺔ‬
.‫ اﻟﻤﺮاد ﻣﻨﺎداﺗﮭﺎ ﻟﻠﺘﻨﻔﯿﺬ‬method ‫ ﻣﻦ أﺟﻞ ﺗﺴﺠﯿﻞ وﺣﻔﻆ ﻣﻜﺎن اﻟﻄﺮﯾﻘﺔ‬Registry ‫أﻧﺸﺊ ﻣﺜﯿﻞ ﻣﻦ اﻟﺴﺠﻞ‬ •
‫ ﺑﺎﻟﺘﺎﻟﻲ أﺻﺒﺤﺖ أﺳﻢ اﻟﻮاﺟﮭﺔ وﻣﺎ ﺗﺤﻮﯾﮫ ﻣﻦ طﺮق )ﻣﻨﺎھﺞ( ﻣﺴﺠﻼ ﻓﻲ‬.stub ‫ ﻣﻊ أﺳﻢ اﻟﻌﻘﺐ‬Hello ‫اﻵن أرﺑﻂ أﺳﻢ اﻟﻮاﺟﮭﺔ‬ •
.‫اﻟﺴﺠﻞ‬
import java.rmi.registry.Registry;
import java.rmi.registry.LocateRegistry;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
public class Server implements Hello

{
public Server() {}
public String sayHello()
{
return "Hello, world!";
}
public static void main(String args[])
{
try
{
Server obj = new Server();
Hello stub = (Hello) UnicastRemoteObject.exportObject(obj, 0);
// Bind the remote object's stub in the registry
Registry registry = LocateRegistry.getRegistry();
registry.bind("Hello", stub);
System.err.println("Server ready");
}
catch (Exception e)
{
System.err.println("Server exception: " + e.toString());
e.printStackTrace();
}
}
}
Client.java ‫اﻟﺒﺮﻧﺎﻣﺞ اﻟﺜﺎﻟﺚ‬
‫ وھﻲ اﻟﻄﺮﯾﻘﺔ‬Hello ‫ اﻟﻤﺮاد ﻣﻨﺎداﺗﮭﺎ ﻓﻲ اﻟﻮاﺟﮭﺔ‬method ‫ أن ﯾﺒﺤﺚ ﻋﻦ اﻟﻄﺮﯾﻘﺔ‬Registry ‫ھﻨﺎ ﻧﻄﻠﺐ ﻣﻦ ﻣﺜﯿﻞ اﻟﺴﺠﻞ‬
.‫ ﺛﻢ ﻧﻄﺒﻊ ﻧﺎﺗﺞ اﻟﺘﻨﻔﯿﺬ‬،sayHello() ‫ ﻟﯿﺪﻟّﻨﺎ ﻋﻠﻰ ﻣﻮﻗﻊ اﻟﻄﺮﯾﻘﺔ‬،‫ اﻟﻤﻀﯿﻒ اﻟﺬي ﯾﺤﻮي اﻟﺴﺠﻞ‬IP ‫ ﻓﻨﻤﺮر ﻋﻨﻮان‬.sayHello()
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class Client
{
private Client() {}
public static void main(String[] args)
2016 ،‫ ﻓرع ﻧﺎﺑﻠس‬- ‫ ﺟﺎﻣﻌﺔ اﻟﻘدس اﻟﻣﻔﺗوﺣﺔ‬- ‫ ﺳﺎﻣر ﺣﺳﻧﻲ ﺟﺎﻟودي‬.‫ م‬.‫ د‬:‫إﻋداد‬ 6
‫{‬
‫;"‪String host = "192.168.1.100‬‬
‫‪try‬‬
‫{‬
‫;)‪Registry registry = LocateRegistry.getRegistry(host‬‬
‫;)"‪Hello stub = (Hello) registry.lookup("Hello‬‬
‫;)(‪String response = stub.sayHello‬‬
‫;)‪System.out.println("response: " + response‬‬
‫}‬
‫)‪catch (Exception e‬‬
‫{‬
‫;))(‪System.err.println("Client exception: " + e.toString‬‬
‫;)(‪e.printStackTrace‬‬
‫}‬
‫}‬
‫}‬
‫ﻟﺘﻨﻔﯿﺬ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ‪ ،‬اﺗﺒﻊ اﻟﺨﻄﻮات اﻟﺘﺎﻟﯿﺔ‪:‬‬
‫• ﺿﻊ ﺟﻤﯿﻊ اﻟﻤﻠﻔﺎت اﻟﺴﺎﺑﻘﺔ )‪ ،(Hello.java, Cient.java, Server.java‬ﻓﻲ ﻣﺠﻠﺪ ‪ ،bin‬ﻓﻲ ﺑﯿﺌﺔ ﺟﺎﻓﺎ اﻟﺘﻄﻮﯾﺮﯾﺔ ‪.JDK‬‬
‫• اﻓﺘﺢ ﻧﺎﻓﺬة ‪ ،DOS‬ﺛﻢ اﻧﺘﻘﻞ إﻟﻰ اﻟﻤﺠﻠﺪ اﻟﺬي ﯾﺤﻮي اﻟﻤﻠﻔﺎت اﻟﺜﻼث ﻓﻲ ال ‪.bin‬‬
‫• ﺻﻨﻒ ‪ ،compile‬اﻟﺒﺮاﻣﺞ اﻟﺜﻼﺛﺔ ﻣﻌﺎ ﻣﺴﺘﺨﺪﻣﺎ اﻷﻣﺮ‪javac Hello.java Client.java Server.java :‬‬
‫• اﻓﺘﺢ ﺷﺎﺷﺔ اﻟﺪوس ‪ ،cmd‬ﺛﻢ اﺑﺪأ اﻟ ِﺴ ِﺠﻞ ﻣﺴﺘﺨﺪﻣﺎ اﻷﻣﺮ ‪.start rmiregistry‬‬
‫• ﻣﻦ ﻧﻔﺲ ﻧﺎﻓﺬة ‪ DOS‬اﻟﺴﺎﺑﻘﺔ اﻟﺘﻲ ﺑﺪأت ﺑﮭﺎ اﻟﺴﺠﻞ‪ ،‬ﺷ ّﻐﻞ )اﺑﺪأ( ﺑﺮﻧﺎﻣﺞ اﻟﺨﺎدم ‪ :server‬ﻣﺴﺘﺨﺪﻣﺎ اﻷﻣﺮ اﻟﺘﺎﻟﻲ‪:‬‬
‫‪“start java -Djava.rmi.server.codebase=file:C:/Java/jdk1.8.0_40/bin/ Server”.‬‬
‫ﻻﺣﻆ أن ھﻨﺎك ﻧﺎﻓﺬﺗﯿﻦ ﯾﺘﻢ ﻓﺘﺤﮭﻤﺎ ﻋﻨﺪ ﺗﻨﻔﯿﺬ أﻣﺮ ﺗﺸﻐﯿﻞ ﻛﻞ ﻣﻦ اﻟﺴﺠﻞ ‪ ،registry‬وﻛﺬﻟﻚ اﻟﺨﺎدم ‪.server‬‬
‫اﻵن وﻣﻦ ﻧﺎﻓﺬة ‪ DOS‬ﻣﺴﺘﻘﻠﺔ ﻣﻦ ﻋﻠﻰ ﻧﻔﺲ اﻟﺠﮭﺎز أو ﺟﮭﺎز زﻣﯿﻠﻚ‪ ،‬ﺷﻐﻞ ﺑﺮﻧﺎﻣﺞ اﻟﺰﺑﻮن ‪ ،client‬ﻣﺴﺘﺨﺪﻣﺎ اﻷﻣﺮ ‪.java Client‬‬
‫ﻣﻼﺣﻈﺔ‪ :‬ﻗﺪ ﻻ ﯾﻌﻤﻞ اﻟﺨﺎدم ﻋﻠﻰ ﺟﮭﺎز ﻣﻨﻔﺼﻞ ﺑﺴﺒﺐ ﻣﺸﺎﻛﻞ ﻓﻲ ‪ ،security‬ﻓﺤﺎول ﺣﻠﮭﺎ ﻣﻊ ﻣﺪﯾﺮ اﻟﺸﺒﻜﺔ إن ﺣﺼﻠﺖ ﺗﻠﻚ اﻟﻤﺸﻜﻠﺔ‪.‬‬
‫ﺗﺪرﯾﺐ ‪ :1‬اﺷﺮح آﻟﯿﺔ ﻋﻤﻞ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﺑﻌﺪ اﻻطﻼع ﻋﻠﻰ اﻟﺮاﺑﻂ اﻟﺘﺎﻟﻲ ﻣﻦ ﻣﻮﻗﻊ أوراﻛﻞ‪:‬‬
‫‪https://docs.oracle.com/javase/8/docs/technotes/guides/rmi/hello/hello-world.html‬‬
‫اﻟﻨﺸﺎط اﻟﺼﻔﻲ اﻟﺜﺎﻧﻲ‬
‫ﻣﻌﻤﺎرﯾﺔ وﺳﯿﻂ طﻠﺐ اﻷھﺪاف اﻟﻤﺸﺘﺮﻛﺔ‬
‫‪Common Object Request Broker‬‬

‫)‪Architecture (CORBA‬‬
‫ﻋﺰﯾﺰي اﻟﺪارس‪ ،‬ﺗﻌﺘﺒﺮ ﻟﻐﺔ ﺗﻌﺮﯾﻒ اﻟﻮاﺟﮭ�ﺎت )‪ Interface Definition Language (IDL‬ﻣ�ﻦ ﺗﻘﻨﯿ�ﺎت اﻷھ�ﺪاف اﻟﻤﻮزﻋ�ﺔ‪ ،‬ﺣﯿ�ﺚ‬
‫ﺗﺘﻮاﺻﻞ ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻷھﺪاف‪ ،‬ﻣﺘﻮاﺟﺪة ﻋﻠﻰ ﻧﻈﻢ ﺗﺸﻐﯿﻞ ﻣﺨﺘﻠﻔﺔ‪ ،‬ﻣﻦ ﺧﻼل ﺷﺒﻜﺔ‪ .‬ھﺬه اﻟﻠﻐﺔ ﺗﺴﮭﻞ ﻣﻦ اﻟﺘﻮاﺻﻞ ﺑ�ﯿﻦ اﻷھ�ﺪاف ﺑﻐ�ﺾ‬
‫اﻟﻨﻈﺮ ﻋﻦ اﻟﻠﻐﺎت اﻟﻤﺴ�ﺘﺨﺪﻣﺔ ﺳ�ﻮاء ﻛﺎﻧ�ﺖ ‪ Java‬أو ‪ C++‬أو ‪ COBOL‬أو ﻏﯿﺮھ�ﺎ ﻣ�ﻦ اﻟﻠﻐ�ﺎت‪ .‬طﺒﻌ�ﺎ ھ�ﺬا ﻣﻤﻜ�ﻦ ﻷن ‪ IDL‬ﻻ ﺗﻌﺘﻤ�ﺪ‬
‫ﻋﻠﻰ ﻟﻐﺔ ﺑﺮﻣﺠﺔ ﺑﻌﯿﻨﮭﺎ‪ ،‬وإﻧﻤﺎ ﺗﺘﺒﻨﻰ ﻣﺒﺪأ ﻋﻤﻞ ﻣﻌﻤﺎرﯾ�ﺔ وﺳ�ﯿﻂ طﻠ�ﺐ اﻷھ�ﺪاف اﻟﻤﺸ�ﺘﺮﻛﺔ ‪Common Object Request Broker‬‬
‫)‪ .Architecture (CORBA‬ﺗ��ﻢ ﺗﻄ��ﻮﯾﺮ ھ��ﺬه اﻟﻤﻌﻤﺎرﯾ��ﺔ ﻣ��ﻦ ﻗﺒ��ﻞ ﺗﺠﻤ��ﻊ ﺿ��ﺨﻢ ﻣ��ﻦ اﻟﺸ��ﺮﻛﺎت اﻟﺼ��ﺎﻧﻌﺔ ﯾﺴ��ﻤﻰ ‪Object‬‬
‫)‪ Management Group (OMG‬ﻣﻦ أﺟﻞ اﻟﺘﻮاﺻﻞ ﺑﯿﻦ اﻷھ�ﺪاف اﻟﻤﻮزﻋ�ﺔ )اﻟ�ﻨﻈﻢ اﻟﻤﻮزﻋ�ﺔ(‪ .‬ﻓﻜ�ﻞ ﻟﻐ�ﺔ ﻣ�ﻦ ﻟﻐ�ﺎت اﻟﺒﺮﻣﺠ�ﺔ اﻟﺘ�ﻲ‬
‫ﺗﺪﻋﻢ ‪ CORBA‬ﻟﺪﯾﮭﺎ طﺮﯾﻘﺘﮭﺎ ﻓﻲ اﻟﻨﻘﻞ ‪ mapping‬ﻣﻦ ‪ IDL‬إﻟﻰ ﺗﻠﻚ اﻟﻠﻐﺔ‪ .‬ﻓﻤ�ﺜﻼ ‪ Java IDL‬ﺗ�ﺪﻋﻢ اﻟﻨﻘ�ﻞ إﻟ�ﻰ ﻟﻐ�ﺔ ﺟﺎﻓ�ﺎ‪ .‬ﻟﻠﺘﻮاﺻ�ﻞ‬
‫ﺑﯿﻦ أھﺪاف ﻣﺘﻮاﺟﺪة ﻋﻠﻰ ﻣﻨﺼﺎت ﻣﺨﺘﻠﻔ�ﺔ )اﺧ�ﺘﻼف ﻧﻈ�ﻢ اﻟﺘﺸ�ﻐﯿﻞ وﻟﻐ�ﺎت ﺑﺮﻣﺠ�ﺔ(‪ ،‬ﺗ�ﻮﻓﺮ ﻣﻌﻤﺎرﯾ�ﺔ ‪ CORBA‬وﺳ�ﯿﻂ ﯾﺴ�ﻤﻰ ‪،ORB‬‬
‫وھﻮ ﻓﻲ ﻟﻐﺔ ﺟﺎﻓﺎ ﻋﺒﺎرة ﻋﻦ ﻣﻜﺘﺒﺔ أﺻﻨﺎف ‪ ،class library‬ﺗﻤﻜﻦ اﻟﺘﻮاﺻﻞ ﺑﯿﻦ ﺗﻄﺒﯿﻘﺎت ‪ Java IDL‬وﺗﻄﺒﯿﻘﺎت ‪.CORBA‬‬
‫ھﺬه اﻟﺘﺠﺮﺑﺔ ﺗﻌﻠﻤﻚ‪ ،‬ﻋﺰﯾﺰي اﻟﺪارس‪ ،‬اﻟﻘﻮاﻋﺪ اﻷﺳﺎﺳﯿﺔ ﻟﺒﻨﺎء ﺗﻄﺒﯿﻘﺎت ﻣﻮزﻋﺔ ﻗﺎﺋﻤﺔ ﻋﻠﻰ ﻣﻌﻤﺎرﯾﺔ ‪ CORBA‬ﺑﺎﺳﺘﺨﺪام ‪.Java IDL‬‬
‫ﺣﯿﺚ ﺳﺘﻌﻤﻞ ﻋﻠﻰ ﺑﻨﺎء ﻣﺜﺎل ‪ Hello World‬ﻛﻨﻈﺎم ﻣﻮزع‪ ،‬واﻟﺬي ﻟﮫ ﻋﻤﻠﯿﺔ واﺣﺪة ﻓﻘﻂ وھﻲ إﻋﺎدة ﺳﻠﺴﻠﺔ ‪ string‬ﻟﻠﻄﺒﺎﻋﺔ‪.‬‬
‫اﻟﻌﻼﻗﺔ اﻟﺘﻲ ﺗﺮﺑﻂ أي ﻧﻈﺎم ﻣﻮزع )أو أھﺪاف ﻣﻮزﻋﺔ( ﻟﮭﺎ ﺟﺎﻧﺒ�ﺎن وھﻤ�ﺎ اﻟﺰﺑ�ﻮن ‪ client‬واﻟﺨ�ﺎدم ‪ .server‬ﯾ�ﻮﻓﺮ اﻟﺨ�ﺎدم واﺟﮭ�ﺔ ﺑﻌﯿ�ﺪة‬
‫‪ ،remote interface‬وﻋﻠﯿﮫ ﻓﺈن اﻟﺰﺑﻮن ﯾﺴﺘﺪﻋﻲ واﺟﮭﺔ ﺑﻌﯿﺪة‪ .‬ھﺬه اﻟﻌﻼﻗﺔ ﻣﺸﺘﺮﻛﺔ ﻣﻊ ﺟﻤﯿﻊ اﻟﻤﻌﺎﯾﯿﺮ اﻟﺘﻲ ﺗﺘﺒﻨﻰ اﻷھ�ﺪاف اﻟﻤﻮزﻋ�ﺔ‬
‫ﻣﺜ��ﻞ ‪ CORBA‬و ‪ RMI‬و ‪ .RMI-IIOP‬ﻻﺣ��ﻆ أن اﻟﻜﻠﻤ��ﺎت ﺧ��ﺎدم وزﺑ��ﻮن‪ ،‬ﺗﻌﺮﻓ��ﺎن ھﻨ��ﺎ ﺗﻮاﺻ��ﻞ ﺑ��ﯿﻦ أھ��ﺪاف ‪object-level‬‬
‫‪ interaction‬وﻟﯿﺲ ﺗﻮاﺻﻞ ﺑﯿﻦ ﺗﻄﺒﯿﻘﺎت ‪ ،application-level interaction‬ﺑﺤﯿﺚ ﯾﺼﺒﺢ أي ﺗﻄﺒﯿﻖ ﻟﮭﺬا اﻟﮭﺪف ﻋﺒﺎرة ﻋﻦ ﺧ�ﺎدم‬
‫وﻟﺬاك اﻟﮭﺪف ﻋﺒﺎرة ﻋﻦ زﺑﻮن‪ .‬أي أن اﻟﺘﻄﺒﯿﻖ ﻧﻔﺴﮫ ﯾﻤﻜﻦ أن ﯾﺤﻮي زﺑﻮن وﺧﺎدم ﻓﻲ ﻧﻔﺲ اﻟﻮﻗﺖ‪ .‬ﻓﻲ اﻟﺤﻘﯿﻘ�ﺔ‪ ،‬ھ�ﺪف واﺣ�ﺪ ﻣﻤﻜ�ﻦ أن‬
‫ﯾﻜﻮن زﺑﻮن ﻟﻮاﺟﮭﺔ ﺗﺎﺑﻌﺔ ﻟﮭﺪف ﺑﻌﯿﺪ‪ ،‬وﻓﻲ ﻧﻔﺲ اﻟﻮﻗﺖ‪ ،‬ﯾﻨﻔﺬ واﺟﮭﺔ ﺳﯿﺘﻢ اﺳﺘﺪﻋﺎﺋﮭﺎ ﻋﻦ ﺑﻌﺪ ﻣﻦ ط�ﺮف أھ�ﺪاف أﺧ�ﺮى‪ .‬اﻟﺼ�ﻮرة أدﻧ�ﺎه‬
‫ﺗﻮﺿ�ﺢ ﻛﯿ�ﻒ أن ھ�ﺪف ﻣ��ﻮزع ﺑﻄﺮﯾﻘ�ﺔ واﺣ�ﺪة ‪ one-method distributed object‬ﻣﺸ�ﺘﺮك ﺑ��ﯿﻦ ﺧ�ﺎدم وزﺑ�ﻮن ‪ CORBA‬ﻟﺘﻨﻔﯿ��ﺬ‬
‫ﺻﻨﻒ اﻟﺘﻄﺒﯿﻖ ‪.Hello World‬‬
‫‪https://docs.oracle.com/javase/8/docs/technotes/guides/idl/GShome.html‬‬
‫ﻓﻲ ﺟﮭﺔ اﻟﺰﺑﻮن‪ ،‬ﯾﺤﺘﻮي اﻟﺘﻄﺒﯿﻖ ﻋﻠﻰ ﻣﺮﺟﻊ ﻟﻠﮭﺪف اﻟﺒﻌﯿﺪ‪ .‬اﻟﻤﺮﺟﻊ اﻟﮭﺪف ﻟﮫ طﺮﯾﻘﺔ ﻋﻘﺐ ‪ ،stub‬واﻟﺘﻲ ﻣﺆﻗﺘﺎ ﺗﺤﻞّ ﻣﻜﺎن )ﺗﺴﺘﺒﺪل(‬
‫اﻟﻄﺮﯾﻘﺔ اﻟﺘﻲ ﺳﯿﺘﻢ اﺳﺘﺪﻋﺎﺋﮭﺎ ﻋﻦ ﺑﻌﺪ‪ .‬اﻟﻌﻘﺐ ‪ stub‬ھﻮ ﻓﻲ اﻟﺤﻘﯿﻘﺔ ﻣﺒَﺮ َﻣﺞ ﻓﻲ داﺧﻞ ‪ ،ORB‬وﺑﺎﻟﺘﺎﻟﻲ اﺳﺘﺪﻋﺎؤه ﯾﺴﺘﺤﻀﺮ أﯾﻀﺎ‬
‫ﺗﺤﻮل اﻻﺳﺘﺤﻀﺎر إﻟﻰ اﻟﺨﺎدم‪.‬‬
‫إﻣﻜﺎﻧﯿﺎت اﺗﺼﺎل ‪ ،ORB‬واﻟﺘﻲ ﺑﺪورھﺎ ﱢ‬
‫ﻓﻲ ﺟﮭﺔ اﻟﺨﺎدم‪ ،‬ﻓﺈن ‪ ORB‬ﯾﺴﺘﺨﺪم ﻛﻮد اﻟﻤﻔﺘﺎح اﻟﮭﯿﻜﻠﻲ ‪ ،skeleton‬ﻟﺘﺮﺟﻤﺔ اﻻﺳﺘﺪﻋﺎء ﻋﻦ ﺑﻌﺪ إﻟﻰ اﺳﺘﺪﻋﺎء طﺮﯾﻘﺔ ‪ method‬ﻋﻠﻰ‬
‫اﻟﮭﺪف اﻟﻤﺤﻠﻲ‪ .‬ﯾﻌﻤﻞ اﻟﻤﻔﺘﺎح اﻟﮭﯿﻜﻠﻲ ‪ skeleton‬ﻋﻠﻰ ﺗﺮﺟﻤﺔ اﻻﺳﺘﺪﻋﺎء ‪ ،call‬وأﯾﺔ ﻗﯿﻢ ‪ parameters‬إﻟﻰ اﻟﻨﺴﻖ اﻟﻤﻨﺎﺳﺐ ﻟﻠﺘﻨﻔﯿﺬ‬
‫وﯾﺴﺘﺪﻋﻲ اﻟﻄﺮﯾﻘﺔ اﻟﺘﻲ ﺗﻢ اﺳﺘﺤﻀﺎرھﺎ‪ .‬ﻋﻨﺪﻣﺎ ﯾﺘﻢ ﺗﻨﻔﯿﺬ اﻟﻄﺮﯾﻘﺔ ‪ ،method‬وﺗﻌﯿﺪ ﻗﯿﻤﺔ‪ ،‬ﻓﺈن ﻛﻮد اﻟﻤﻔﺘﺎح اﻟﮭﯿﻜﻠﻲ ‪ skeleton‬ﯾﺤ ّﻮل‬
‫ﻧﺘﺎﺋﺞ أو أﺧﻄﺎء‪ ،‬وﯾﻌﯿﺪ إرﺳﺎﻟﮭﺎ إﻟﻰ اﻟﺰﺑﻮن ﻋﻦ طﺮﯾﻖ ‪ .ORB‬ﻣﺎ ﺑﯿﻦ ‪ ORBs‬ﻓﺈن اﻻﺗﺼﺎل ﯾﺘﻢ ﻋﻦ طﺮﯾﻖ ﺑﺮوﺗﻮﻛﻮل ‪ IIOP‬وھﻮ‬
‫اﺧﺘﺼﺎر ‪ .Internet Inter ORB Protocol‬ﺑﺮوﺗﻮﻛﻮل ‪ ،IIOP‬واﻟﺬي ﯾﻌﺘﻤﺪ ﻋﻠﻰ ﺑﺮوﺗﻮﻛﻮﻻت ‪ ،TCP/IP‬ﯾﻌﺮف ﺑﺪوره ﻛﯿﻔﯿﺔ‬
‫ﻗﯿﺎم ‪ ORBs‬ﺑﺘﻤﺮﯾﺮ ﻣﻌﻠﻮﻣﺎت ﻓﯿﻤﺎ ﺑﯿﻨﮭﺎ‪ .‬ﻛﻤﺎ ھﻮ اﻟﺤﺎل ﻓﻲ ﻛﻞ ﻣﻦ ‪ CORBA‬و ‪ ،IDL‬ﻓﺈن ‪ IIOP‬ھﻮ ﻣﻌﯿﺎر اﺗﺼﺎل ﻣﻌﺮف ﻣﻦ‬
‫ﻗﺒﻞ ﺗﺠﻤﻊ ‪.OMG‬‬
‫اﻷھﺪاف‬
‫أن ﺗﺘﻌﺮف ﻋﻠﻰ ﻟﻐﺔ ﺗﻌﺮﯾﻒ اﻟﻮاﺟﮭﺎت ‪.IDL‬‬ ‫‪.1‬‬
‫أن ﺗﺘﻌﺮف ﻋﻠﻰ ﻣﻌﻤﺎرﯾﺔ وﺳﯿﻂ طﻠﺐ اﻷھﺪاف اﻟﻤﺸﺘﺮﻛﺔ ‪ ،CORBA‬وﺑﯿﺌﺘﮭﺎ‪.‬‬ ‫‪.2‬‬
‫أن ﺗﺒﻨﻲ ﻣﺜﺎﻻ ﯾﻮﺿﺢ طﺮﯾﻘﺔ اﻻﺗﺼﺎل ﺑﯿﻦ اﻷھﺪاف ﻣﺴﺘﺨﺪﻣﺎ ﺑﺮاﻣﺞ ﺟﺎﻓﺎ وﺗﻘﻨﯿﺔ ‪.CORBA‬‬ ‫‪.3‬‬
‫أن ﺗﺬﻛﺮ اﻟﻔﺮق ﺑﯿﻦ ﺗﻘﻨﯿﺘ ّﻲ اﻻﺗﺼﺎل ‪ RMI‬و ‪.CORBA‬‬ ‫‪.4‬‬
‫ﺧﻄﻮات ﻋﻤﻞ اﻟﺘﺠﺮﺑﺔ‬

‫ھﺬه اﻟﺘﺠﺮﺑﺔ ﺗﻌﻠﻤﻚ ﻋﺰﯾﺰي اﻟﺪارس أﺳﺎﺳﯿﺎت ﺑﻨﺎء ﻧﻈﺎم ﻣﻮزع ﺑﺎﺳﺘﺨﺪام ﺗﻘﻨﯿﺔ اﻻﺗﺼﺎل ‪ ،CORBA‬ﺣﯿﺚ ﺗﺴﺘﺨﺪم ﻟﻐﺔ ﺟﺎﻓﺎ ﻓﻲ ﺑﻨﺎء‬
‫ﺑﺮاﻣﺞ اﻟﻤﺜﺎل‪ .‬ﺳﯿﺘﻢ ﺑﻨﺎء اﻟﻤﺜﺎل اﻟﻜﻼﺳﯿﻜﻲ ‪ ،Hello World‬ﻛﺘﻄﺒﯿﻖ ﻣﻮزع‪ ،‬ﻟﮫ طﺮﯾﻘﺔ واﺣﺪة ﻓﻘﻂ ﺗﻌﯿﺪ ﺳﻠﺴﻠﺔ ﻟﻠﻄﺒﺎﻋﺔ‪ .‬ﺑﺎﻟﺮﻏﻢ ﻣﻦ‬
‫ﺑﺴﺎطﺔ ھﺬا اﻟﻤﺜﺎل‪ ،‬إﻻ أﻧﮫ ﯾﻌﻠﻤﻚ ﺑﻨﺎء ﻣﻌﻈﻢ ﺑﺮاﻣﺞ ‪ CORBA‬اﻟﺘﻲ ﺗﺴﺘﺨﺪم اﻻﺳﺘﺤﻀﺎر اﻟﺜﺎﺑﺖ ‪ .static invocation‬ﯾﺠﺐ ﺑﻨﺎء‬
‫ﺛﻼﺛﺔ ﺑﺮاﻣﺞ‪ ،‬اﻷول ﺑﺮﻧﺎﻣﺞ اﻟﻮاﺟﮭﺔ ﺑﺎﺳﺘﺨﺪام ﻟﻐﺔ ‪ ،IDL‬واﻟﺜﺎﻧﻲ ﺑﺮﻧﺎﻣﺞ اﻟﺨﺎدم ‪ server‬ﺑﺎﺳﺘﺨﺪام ﻟﻐﺔ ﺟﺎﻓﺎ‪ ،‬واﻟﺜﺎﻟﺚ ﺑﺮﻧﺎﻣﺞ اﻟﺰﺑﻮن‬
‫‪ client‬ﺑﺎﺳﺘﺨﺪام ﻟﻐﺔ ﺟﺎﻓﺎ أﯾﻀﺎ‪.‬‬
‫اﻟﻤﻠﻒ اﻷول ‪Hello.idl‬‬
‫اﻟﺨﻄﻮة اﻷوﻟﻰ ﻋﻠﻰ طﺮﯾﻖ إﻧﺸﺎء ﺗﻄﺒﯿﻖ ‪ CORBA‬ھﻮ أن ﺗﺤﺪد ﺟﻤﯿﻊ اﻷھﺪاف و واﺟﮭﺎﺗﮭﺎ ﺑﺎﺳﺘﺨﺪام ﻟﻐﺔ ‪ ،IDL‬واﻟﺘﻲ ﻟﮭﺎ ﺗﺮﻛﯿﺐ‬
‫ﻣﺸﺎﺑﮫ ﻟﻠﻐﺔ ‪ ،C++‬واﻟﺘﻲ ﯾﻤﻜﻨﮭﺎ ﺗﻌﺮﯾﻒ وﺣﺪات ‪ ،modules‬واﺟﮭﺎت ‪ ،interfaces‬ﺗﺮاﻛﯿﺐ ﺑﯿﺎﻧﺎت ‪ ،data structures‬وأﻛﺜﺮ‪.‬‬
‫اﻟﻜﻮد اﻟﺘﺎﻟﻲ ﻣﻜﺘﻮب ﺑﻠﻐﺔ ‪ ،IDL‬وﯾﺼﻒ ھﺪف ﻣﻦ ﻧﻮع ‪ ،CORBA‬واﻟﺬي طﺮﯾﻘﺘﮫ )(‪ sayHello‬ﺗﻌﯿﺪ ﺳﻠﺴﻠﺔ ﻋﻨﺪ ﻣﻨﺎداﺗﮭﺎ وطﺮﯾﻘﺘﮫ‬
‫)(‪ shutdown‬ﺗﻐﻠﻖ اﻟﻮﺳﯿﻂ ‪.ORB‬‬
‫‪module HelloApp‬‬
‫{‬
‫‪interface Hello‬‬
‫{‬
‫;)(‪string sayHello‬‬
‫;)(‪oneway void shutdown‬‬
‫;}‬
‫;}‬
‫اﻟﻤﻠﻒ اﻟﺜﺎﻧﻲ ‪HelloServer.java‬‬
‫ﯾﺘﻜﻮّ ن ﻣﻠﻒ اﻟﺨﺎدم ﻣﻦ ﺻﻨﻔﯿﻦ ‪ ،two classes‬اﻟﻤﺴﺘﺨﺪَم ‪ servant‬واﻟﺨﺎدم ‪ .server‬اﻟﻤﺴﺘﺨﺪَم ‪ HelloImpl‬ھﻮ ﺗﻨﻔﯿﺬ ﻟﻤﻠﻒ ‪IDL‬‬
‫اﻟﻤﺴﻤﻰ ‪ Hello‬اﻟﺬي ﯾﻌﺮف واﺟﮭﺔ ‪ interface‬ﻓﻲ داﺧﻞ وﺣﺪة ‪ .module‬ﻛﻞ ﻣﺜﯿﻞ ‪ Hello‬ﯾﻨﻔﱠﺬ ﺑﻮﺳﺎطﺔ ﻣﺜﯿﻞ ‪.HelloImpl‬‬
‫اﻟﻤﺴﺘﺨﺪَم ھﻢ ﻣﺜﯿﻞ ﺻﻨﻒ ﻣﺸﺘﻖ ﻣﻦ ‪ ،HelloPOA‬واﻟﺬي ﺗﻢ ﺗﻮﻟﯿﺪه ﺑﺸﻜﻞ أوﺗﻮﻣﺎﺗﯿﻜﻲ ﻋﻨﺪ ﺗﺼﻨﯿﻒ ﻣﻠﻒ ‪ IDL‬ﺑﻮﺳﺎطﺔ اﻷﻣﺮ ‪.idlj‬‬
‫اﻟﻤﺴﺘﺨﺪَم ﯾﺤﺘﻮي ﻋﻠﻰ طﺮﯾﻘﺔ واﺣﺪة ﻟﻜﻞ ﻋﻤﻠﯿﺔ ‪ ،IDL‬وﻓﻲ ھﺬا اﻟﻤﺜﺎل ھﻤﺎ اﻟﻄﺮﯾﻘﺘﺎن )(‪ sayHello‬و )(‪ .shutdown‬ﻓﻲ اﻟﺤﻘﯿﻘﺔ‪،‬‬
‫ﻓﺈن طﺮق اﻟﻤﺴﺘﺨﺪَم ھﻲ ﻧﻔﺲ طﺮق ﺟﺎﻓﺎ اﻻﻋﺘﯿﺎدﯾﺔ‪ .‬اﻟﻜﻮد اﻵﺧﺮ ﻟﻠﺘﻌﺎﻣﻞ ﻣﻊ ‪ ،ORB‬ﻟﻘﯿﺎدة وﺗﺮﺗﯿﺐ ‪ marshalling‬اﻟﻤﺘﻐﯿﺮات‬
‫واﻟﻨﺘﺎﺋﺞ‪ ،‬ﯾﺘﻢ ﺗﺰوﯾﺪھﺎ ﺑﻮﺳﺎطﺔ اﻟﻤﻔﺘﺎح اﻟﮭﯿﻜﻠﻲ ‪.skeleton‬‬
‫ﯾﺤﻮي اﻟﺼﻨﻒ ‪ HelloServer‬ﻋﻠﻰ ﻣﻨﮭﺞ )(‪ ،main‬واﻟﺬي‪:‬‬

‫• ﯾﻨﺸﺊ ﺑﻘﯿﻢ ﻣﺒﺪﺋﯿﺔ ﻣﺜﯿﻞ ‪.ORB‬‬
‫• ﯾﺠﻠﺐ ﻣﺮﺟﻊ ﻟﻠﺠﺬر )‪ Portable Object Adapter (POA‬وﯾﻔ ّﻌﻞ ‪.POAManager‬‬
‫• إﻧﺸﺎء ﻣﺜﯿﻞ ﻣﻦ اﻟﻤﺴﺘﺨﺪَم ‪ ،servant‬وإﺧﺒﺎر وﺳﯿﻂ ‪ ORB‬ﺑﺬﻟﻚ‪ .‬ﯾﺘﻢ إﻧﺸﺎء اﻟﻤﺜﯿﻞ ﻣﻦ ﺧﻼل ﺗﻨﻔﯿﺬ ھﺪف ‪ Hello‬واﺣﺪ‪.‬‬
‫• اﻟﺤﺼﻮل ﻋﻠﻰ ﻣﺮﺟﻊ ھﺪف ‪ CORBA‬ﻟﺴﯿﺎق اﻟﺘﺴﻤﯿﺔ ‪ naming context‬ﺣﯿﺚ ﺳﯿﺘﻢ ﺗﺴﺠﯿﻞ ھﺪف ‪ CORBA‬اﻟﺠﺪﯾﺪ ﻓﯿﮫ‪.‬‬
‫• اﻟﺤﺼﻮل ﻋﻠﻰ ﺳﯿﺎق اﻟﺘﺴﻤﯿﺔ اﻟﺠﺬر‪.‬‬
‫• ﺗﺴﺠﯿﻞ ‪ register‬اﻟﮭﺪف اﻟﺠﺪﯾﺪ ﻓﻲ ﺳﯿﺎق اﻟﺘﺴﻤﯿﺔ ﺑﻤﺴﻤﻰ ‪.Hello‬‬
‫• اﻧﺘﻈﺎر اﺳﺘﺤﻀﺎر ‪ invocation‬اﻟﮭﺪف اﻟﺠﺪﯾﺪ ﻣﻦ اﻟﺰﺑﻮن‪.‬‬
‫ﻣﻼﺣﻈﺔ‪ :‬إن ﻣﻜﯿّﻒ اﻟﮭﺪف ‪ ،object adapter‬ﻋﺒﺎرة ﻋﻦ وﺳﯿﻠﺔ ﻟﺮﺑﻂ طﻠﺐ ‪ ،request‬ﺑﺎﺳﺘﺨﺪام ﻣﺮﺟﻊ اﻟﮭﺪف ﺑﻜﻮد ﻣﻌﯿﻦ‪ ،‬ﻣﻊ ﺧﺪﻣﺔ‬
‫اﻟﻄﻠﺐ‪ .‬ﻣﻜﯿّﻒ اﻟﮭﺪف اﻟﻤﺤﻤﻮل ‪) POA‬ﻗﺎﺑﻠﺔ ﻟﻠﻌﻤﻞ(‪ ،‬ھﻮ ﻧﻮع ﻣﻦ أﻧﻮاع ‪ ،object adapter‬واﻟﺬي‪:‬‬
‫• ﯾﺴﻤﺢ ﻟﻠﻤﺒﺮﻣﺠﯿﻦ ﺑﺈﻧﺸﺎء أھﺪاف ﺗﻨﻔﯿﺬﯾﺔ ﻗﺎﺑﻠﺔ ﻟﻠﻌﻤﻞ ﺑﯿﻦ ﻣﻨﺘﺠﺎت ‪ ORB‬ﻣﺨﺘﻠﻔﺔ‪.‬‬
‫• ﯾﻮﻓﺮ اﻟﺪﻋﻢ ﻷھﺪاف ﺑﻤﻌ ّﺮف ﻣﺴﺘﻤﺮ ‪ ،persistent‬ﻛﻤﺎ ھﻮ اﻟﺤﺎل ﻓﻲ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ واﻟﺬي ﯾﻤﺜﻞ ‪.persistent example‬‬
‫• ﯾﻮﻓﺮ اﻟﺪﻋﻢ ﻟﺘﻔﻌﯿﻞ ﺷﻔﺎف ‪ transparent activation‬ﻟﻸھﺪاف‪.‬‬
.‫اﻟﺴﻤﺎح ﻟﻤﺴﺘﺨ ّﺪم ﻣﻌﯿﻦ ﺑﺪﻋﻢ اﻟﻌﺪﯾﺪ ﻣﻦ ﻣﻌﺮﻓﺎت اﻷھﺪاف ﺑﺸﻜﻞ ﻣﺘﺰاﻣﻦ‬ •
import HelloApp.*;
import org.omg.CosNaming.*;
import org.omg.CosNaming.NamingContextPackage.*;
import org.omg.CORBA.*;
import org.omg.PortableServer.*;
import org.omg.PortableServer.POA;
import java.util.Properties;
class HelloImpl extends HelloPOA

{
private ORB orb;
public void setORB(ORB orb_val) { orb = orb_val; }
// implement sayHello() method
public String sayHello() { return "\nHello world !!\n"; }
// implement shutdown() method
public void shutdown() { orb.shutdown(false); }
}
public class HelloServer

{
{
try
{
// create and initialize the ORB
ORB orb = ORB.init(args, null);
// get reference to rootpoa & activate the POAManager
POA rootpoa = POAHelper.narrow(orb.resolve_initial_references("RootPOA"));
rootpoa.the_POAManager().activate();
// create servant and register it with the ORB
HelloImpl helloImpl = new HelloImpl();
helloImpl.setORB(orb);
// get object reference from the servant
org.omg.CORBA.Object ref = rootpoa.servant_to_reference(helloImpl);
Hello href = HelloHelper.narrow(ref);
// get the root naming context. NameService invokes the name service
org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");
// Use NamingContextExt which is part of the Interoperable
// Naming Service (INS) specification.
NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);
// bind the Object Reference in Naming
String name = "Hello";
NameComponent path[] = ncRef.to_name( name );
ncRef.rebind(path, href);
System.out.println("HelloServer ready and waiting ...");
// wait for invocations from clients
orb.run();
}
catch (Exception e)
{
System.err.println("ERROR: " + e);
e.printStackTrace(System.out);
}
System.out.println("HelloServer Exiting ...");
}
}
HelloClient.java ‫اﻟﻤﻠﻒ اﻟﺜﺎﻟﺚ‬
:‫ﯾﺘﻢ ﻓﻲ ﺗﻄﺒﯿﻖ اﻟﺰﺑﻮن ﻣﺎ ﯾﻠﻲ‬
.initializations ‫ ﺑﻘﯿﻢ ﻣﺒﺪﺋﯿﺔ‬ORB ‫• إﻧﺸﺎء‬
.root naming context ‫• اﻟﺤﺼﻮل ﻋﻠﻰ ﻣﺮﺟﻊ إﻟﻰ ﺟﺬر ﺳﯿﺎق اﻟﺘﺴﻤﯿﺔ‬
.CORBA ‫ واﺳﺘﻘﺒﺎل ﻣﺮﺟﻊ إﻟﻰ ذﻟﻚ اﻟﮭﺪف ﻣﻦ‬،naming context ‫ ﻓﻲ ﺳﯿﺎق اﻟﺘﺴﻤﯿﺔ‬Hello ‫• اﻟﺒﺤﺚ ﻋﻦ‬
.‫ وطﺒﺎﻋﺔ اﻟﻨﺘﯿﺠﺔ‬shutdown() ‫ و‬sayHello() ‫• اﺳﺘﺤﻀﺎر طﺮق ھﺪف وھﻲ‬
import HelloApp.*;
import org.omg.CosNaming.*;
import org.omg.CosNaming.NamingContextPackage.*;
import org.omg.CORBA.*;
public class HelloClient

{
static Hello helloImpl;
{
try
{
// create and initialize the ORB
ORB orb = ORB.init(args, null);
// get the root naming context
org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");
// Use NamingContextExt instead of NamingContext.
// This is part of the Interoperable naming Service.
NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);
// resolve the Object Reference in Naming
String name = "Hello";
helloImpl = HelloHelper.narrow(ncRef.resolve_str(name));
System.out.println("Obtained a handle on server object: " + helloImpl);
System.out.println(helloImpl.sayHello());
helloImpl.shutdown();
}
catch (Exception e)
{
System.out.println("ERROR : " + e) ;
e.printStackTrace(System.out);
}
}
}
:‫ ﻛﻤﺎ ھﻮ ﻣﻮﺿﺢ ﻓﻲ اﻟﺼﻮرة أدﻧﺎه‬.DOS ‫ ﺛﻢ اﻓﺘﺢ ﻧﺎﻓﺬة‬،bin ‫ ﺿﻊ ﺟﻤﯿﻊ ﻣﻠﻔﺎﺗﻚ ﻓﻲ ﻣﺠﻠﺪ‬،‫ﻟﺘﻨﻔﯿﺬ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ‬
idlj -fall Hello.idl :‫ ﺑﺎﺳﺘﺨﺪام اﻷﻣﺮ‬،Hello.idl ‫ ﻣﻠﻒ‬compile ‫• ﺻﻨﻒ‬
javac HelloServer.java ‫ ﺑﺎﺳﺘﺨﺪام اﻷﻣﺮ‬،HelloServer.java ‫ ﻣﻠﻒ‬compile ‫• ﺻﻨﻒ‬
javac HelloClient.java ‫ ﺑﺎﺳﺘﺨﺪام اﻷﻣﺮ‬،HelloClient.java ‫ ﻣﻠﻒ‬compile ‫• ﺻﻨﻒ‬
start orbd –ORBInitialPort 1050 :‫ ﺑﺎﺳﺘﺨﺪام اﻷﻣﺮ‬1050 ‫ رﻗﻢ‬port ‫ ﻋﻠﻰ ﻣﻨﻔﺬ‬ORB ‫• ﺷﻐﻞ وﺳﯿﻂ‬
:‫• اﻵن ﺷﻐﻞ اﻟﺨﺎدم ﻋﻠﻰ ﻧﻔﺲ اﻟﻤﻨﻔﺬ ﻣﻦ ﻋﻠﻰ ﻣﻨﺼﺔ اﻟﺠﮭﺎز اﻟﻤﺤﻠّﻲ ﺑﺎﺳﺘﺨﺪام اﻷﻣﺮ اﻟﺘﺎﻟﻲ‬
start java HelloServer -ORBInitialPort 1050 -ORBInitialHost localhost
:‫ أن ﺗﺸﻐﻞ اﻟﺰﺑﻮن ﺑﺎﺳﺘﺨﺪام اﻷﻣﺮ اﻟﺘﺎﻟﻲ‬،‫ ﻋﺰﯾﺰي اﻟﺪارس‬،‫• ﯾﻤﻜﻨﻚ اﻵن‬
java HelloClient -ORBInitialPort 1050 -ORBInitialHost localhost
‫ﻋﻨﺪ ﺗﻨﻔﯿﺬ اﻟﻤﺜﺎل‪ ،‬ﯾﺘﻢ إﻋﻄﺎء رﻗﻢ ﻋﻠﻰ ﺷﻜﻞ ﺳﻠﺴﻠﺔ ﻣﻦ اﻟﻘﯿﻢ ﺑﺎﻟﻨﻈﺎم اﻟﺴﺪاﺳﻲ ﻋﺸﺮي ‪ Hexadecimal‬ﯾﺴﻤﻰ ‪Interoperable‬‬
‫)‪ ،Object Reference (IOR‬وھﺬا ﻋﺒﺎرة ﻋﻦ ﻣﺤﺪد ﻣﻜﺎن ﻟﻤﺮﺟﻊ اﻟﮭﺪف‪ .‬ﯾﺤﻮي ﻓﻲ داﺧﻠﮫ ﻣﺜﻼ ﻋﻨﻮان ‪ ،IP‬ورﻗﻢ ﻣﻨﻔﺬ ‪،port‬‬
‫وﻣﺮﺟﻊ ھﺪف ﻟﻠﺨﺎدم ‪ ،servant‬اﻟﺦ‪.‬‬
‫ﺗﺪرﯾﺐ‪ :‬ﺑﻤﺴﺎﻋﺪة ﻣﺸﺮﻓﻚ اﻷﻛﺎدﯾﻤﻲ‪ ،‬اﺷﺮح آﻟﯿﺔ ﻋﻤﻞ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﺑﻌﺪ اﻻطﻼع ﻋﻠﻰ اﻟﺮاﺑﻂ اﻟﺘﺎﻟﻲ ﻣﻦ ﻣﻮﻗﻊ أوراﻛﻞ‪:‬‬
‫‪https://docs.oracle.com/javase/8/docs/technotes/guides/idl/jidlExample.html‬‬
‫اﻟﻨﺸﺎط اﻟﺼﻔﻲ اﻟﺜﺎﻟﺚ‬
‫ﻣﻘﺪﻣﺔ ﻓﻲ ﻟﻐﺔ ﺑﺮﻣﺠﺔ اﻟﻮﯾﺐ ﺑﻲ اش ﺑﻲ‬

‫‪Introducing PHP‬‬
‫أوﻻ‪ :‬اﻷھﺪاف‬
‫‪ .1‬اﻟﺘﻌﺮف ﻋﻠﻰ ﺑﯿﺌﺔ ﻋﻤﻞ اﻟﺘﻄﺒﯿﻖ ‪.XAMPP‬‬
‫‪ .2‬اﻟﺘﻌﺮف ﻋﻠﻰ ﻣﺠﺎل ﻋﻤﻞ ﺧﺎدم اﻟﻮﯾﺐ ‪.Apache‬‬
‫‪ .3‬اﻟﺘﻌﺮف ﻋﻠﻰ ﺑﯿﺌﺔ ﻋﻤﻞ ﻟﻐﺔ اﻟﻮﯾﺐ ‪.PHP‬‬
‫‪ .4‬ﺗﻘﺪﯾﻢ ﻧﺒﺬة ﻋﻦ ﺑﺮاﻣﺞ ﻟﻐﺔ ‪ ،PHP‬وﺧﺼﻮﺻﺎ اﻟﻤﺘﻐﯿﺮات واﻟﺪوال‪.‬‬
‫‪ .5‬ﻛﺘﺎﺑﺔ ﺑﺮاﻣﺞ ﺑﺴﯿﻄﺔ ﺑﻠﻐﺔ ‪ PHP‬وﺗﻨﻔﯿﺬھﺎ ﻣﻦ ﺧﻼل ﺧﺎدم ‪ Apache‬ﻋﻠﻰ ﺟﮭﺎز اﻟﺤﺎﺳﻮب اﻟﻤﺤﻠﻲ‪.‬‬
‫ﺛﺎﻧﯿﺎ‪ :‬ﻣﻘﺪﻣﺔ‬
‫إن ﻟﻐﺔ ﺑﺮﻣﺠﺔ اﻟﻮﯾﺐ ﺑﻲ إش ﺑﻲ ‪ PHP‬ﻟﻐﺔ ﻣﻔﺘﻮﺣﺔ اﻟﻤﺼﺪر ‪) open source‬ﯾﻤﻜﻦ ﺗﺤﻤﯿﻠﮭﺎ ﻣﺠﺎﻧﺎ ﻣﻦ اﻟﻤﻮﻗﻊ ‪،(www.php.net‬‬
‫واﻻﺧﺘﺼﺎر ھﻮ ﻟﻠﻤﺼﻄﻠﺢ ”‪ .“Hypertext Preprocessor‬ھﻲ ﻣﻦ ﻟﻐﺎت اﻟﺘﻌﻠﯿﻤﺎت ‪ scripting language‬أي أﻧﮭﺎ ﻻ ﺗﺤﺘﺎج إﻟﻰ‬
‫ﺗﺼﻨﯿﻒ ‪ compile‬ﻣﺜﻞ ﻟﻐﺎت ‪ .Java, C, C++‬أﻣﺎ ﻣﻠﻔﺎﺗﮭﺎ ﻓﯿﺠﺐ أن ﯾﻜﻮن اﻣﺘﺪادھﺎ ”‪ “.php‬وﯾﻤﻜﻦ أن ﺗﺤﺘﻮي ﻧﺼﻮص أو ﻛﻮد‬
‫إﺣﺪى ﻟﻐﺎت اﻟﻮﯾﺐ ﻣﺜﻞ ‪ ،JavaScript, CSS, HTML‬طﺒﻌﺎ ﺑﺎﻹﺿﺎﻓﺔ إﻟﻰ ﻛﻮد اﻟﻠﻐﺔ ﻧﻔﺴﮭﺎ ‪ ،PHP‬ﺣﯿﺚ ﯾﺘﻢ ﺗﻨﻔﯿﺬ ھﺬه اﻟﻤﻠﻔﺎت ﻋﻠﻰ‬
‫اﻟﺨﺎدم ‪ ،server‬وﻧﺘﺎﺋﺞ اﻟﺘﻨﻔﯿﺬ ﺗﻌﻮد إﻟﻰ اﻟﻤﺴﺘﺨﺪم ﻋﻠﻰ ﺟﮭﺎز اﻟﺤﺎﺳﻮب اﻟﺰﺑﻮن ‪ client‬ﻓﻲ ﺻﻔﺤﺔ ‪ ،HTML‬وﯾﻤﻜﻨﮭﺎ إﻧﺘﺎج ﻣﻠﻔﺎت‬
‫ﻧﻮع ﺻﻮر أو ‪ PDF‬أو ‪ ،XML‬أو ﺣﺘﻰ أﻓﻼم ﻓﻼش‪ .‬ﯾﻤﻜﻦ ﻟﻠﻐﺔ ‪ PHP‬أن ﺗﻌﻤﻞ ﻋﻠﻰ إﻧﺸﺎء‪/‬ﺣﺬف ﻣﻠﻔﺎت ﻋﻠﻰ ﺧﺎدم‪ ،‬ﻗﺮاءة‪/‬ﻛﺘﺎﺑﺔ‬
‫ﻣﻠﻔﺎت ﻋﻠﻰ ﺧﺎدم‪ ،‬إﻧﺸﺎء‪/‬ﺣﺬف‪/‬ﺗﻐﯿﯿﺮ ﻗﻮاﻋﺪ ﺑﯿﺎﻧﺎت ﻋﻠﻰ ﺧﺎدم‪ ،‬وﯾﻤﻜﻨﮭﺎ ﻛﺬﻟﻚ اﻟﺘﺤﻜﻢ ﺑﻮﺻﻮل اﻟﻤﺴﺘﺨﺪﻣﯿﻦ‪ ،‬وﺗﺸﻔﯿﺮ اﻟﺒﯿﺎﻧﺎت‪.‬‬
‫ھﺬه اﻟﻠﻐﺔ ﻣﺪﻋﻮﻣﺔ ﻣﻦ ﻗﺒﻞ اﻟﻌﺪﯾﺪ ﻣﻦ ﺧﻮادم اﻟﻮﯾﺐ ﻣﺜﻞ ‪ IIS‬و ‪ ،Apache‬وﯾﻤﻜﻦ أن ﺗﻨﻔﺬ ﻋﻠﻰ ﻣﻌﻈﻢ ﻧﻈﻢ اﻟﺘﺸﻐﯿﻞ ﻣﺜﻞ اﻟﻮﯾﻨﺪوز‬
‫واﻟﻠﯿﻨﻮﻛﺲ واﻟﯿﻮﻧﻜﺲ واﻟﻤﺎﻛﻨﺘﻮش‪ .‬ﻛﻤﺎ أﻧﮭﺎ ﺗﺪﻋﻢ اﻟﻌﺪﯾﺪ ﻣﻦ ﻗﻮاﻋﺪ اﻟﺒﯿﺎﻧﺎت وﻓﻲ ﻣﻘﺪﻣﺘﮭﺎ ‪ MySQL‬اﻟﺘﻲ أﺻﺒﺤﺖ ﺗﺤﻤﻞ اﻻﺳﻢ‬
‫‪ .MariaDB‬ﻟﺬﻟﻚ وﻣﻦ أﺟﻞ اﻟﻌﻤﻞ ﺑﮭﺬه اﻟﻠﻐﺔ‪ ،‬ﯾﺠﺐ ﺗﺤﻤﯿﻞ وﺗﻨﺼﯿﺐ )‪ (download & install‬ﺧﺎدم وﯾﺐ ‪ ، web server‬ﺛﻢ ﺑﻌﺪ‬
‫ذﻟﻚ ﯾﻤﻜﻦ ﺗﺤﻤﯿﻞ ﻛﻞ ﻣﻦ ‪ PHP‬و ‪ .MySQL‬وﻟﻜﻦ وﺑﺪﻻ ﻣﻦ ﻛﻞ ھﺬه اﻟﺨﻄﻮات‪ ،‬ﯾﻤﻜﻦ ﺗﺤﻤﯿﻞ ﺗﻄﺒﯿﻖ ‪ XAMPP‬ﻣﻦ ﻣﻮﻗﻊ أﺻﺪﻗﺎء‬
‫أﺑﺎﺗﺸﻲ ‪ ،https://www.apachefriends.org/download.html‬واﻟﺬي ﯾﺤﻮي واﺟﮭﺔ ﺗﺤﻜﻢ ﺑﺎﻹﺿﺎﻓﺔ إﻟﻰ ﻣﺎ ﯾﻠﻲ‪:‬‬
‫‪Apache 2.4.18, MariaDB 10.1.13, PHP 7.0.8, phpMyAdmin 4.5.1, OpenSSL 1.0.2, XAMPP Control‬‬
‫‪Panel 3.2.2, Webalizer 2.23-04, Mercury Mail Transport System 4.63, FileZilla FTP Server 0.9.41,‬‬
‫‪Tomcat 7.0.56 (with mod_proxy_ajp as connector), Strawberry Perl 7.0.56 Portable.‬‬
‫ﻛﻤﺎ ﺗﻼﺣﻆ ﻋﺰﯾﺰي اﻟﺪارس‪ ،‬ﻓﺈن اﻟﻔﺮق اﻷﺳﺎس ﻓﻲ اﻹﺻﺪار اﻟﺤﺎﻟﻲ ﻣﻦ ‪ XAMPP‬واﻹﺻﺪار اﻟﺴﺎﺑﻖ ھﻮ أن اﻹﺻﺪار اﻟﺴﺎﺑﻖ ﯾﺤﻮي‬
‫ﻗﻮاﻋﺪ اﻟﺒﯿﺎﻧﺎت ﺑﺎﺳﻢ ‪ ،MySQL‬واﻹﺻﺪار اﻟﺤﺎﻟﻲ ﯾﺤﻤﻞ أﺳﻢ ﻗﻮاﻋﺪ اﻟﺒﯿﺎﻧﺎت ‪ .MariaDB‬ﻓﻲ اﻟﺤﻘﯿﻘﺔ ﻓﺈﻧﮫ وﺑﺎﻟﻨﺴﺒﺔ ﻟﻠﻤﺴﺘﺨﺪم ﻻ ﻓﺮق‬
‫ﻓﻲ اﻷواﻣﺮ أو اﻟﺘﻌﺎﻣﻞ ﺑﯿﻨﮭﻤﺎ‪ .‬إﻻ أن ﻣﺒﺮﻣﺠﻲ ﻣﺠﺘﻤﻊ أﺑﺎﺗﺸﻲ ‪ ،Apache Community‬ﻗﺪ ﻗﺮروا أن ﯾﺼﻤﻤﻮا ‪ MariaDB‬ﺑﺴﺐ‬
‫ﻣﺸﺎﻛﻞ ﻣﻊ اﻟﺸﺮﻛﺔ اﻷم أوراﻛﻞ اﻟﺘﻲ اﺷﺘﺮت ‪ MySQL‬ﻣﻦ ﺷﺮﻛﺔ ﺻﻦ ﻣﺴﺒﻘﺎ‪ ،‬وﻟﻢ ﺗﮭﺘﻢ ﺑﺘﻄﻮﯾﺮه ﺑﺴﺒﺐ وﺟﻮد ﻗﻮاﻋﺪ ﺑﯿﺎﻧﺎﺗﮭﺎ أﺻﻼ‪.‬‬
‫ﻟﺬﻟﻚ ﺗﻢ ﺗﺼﻤﯿﻢ ‪ MariaDB‬ﻣﻦ ﻗِﺒﻞ ﻣﺒﺮﻣﺠﻲ ﻣﺠﺘﻤﻊ أﺑﺎﺗﺸﻲ ﺑﺪون أي ﻓﺮوق‪ ،‬وﺑﻄﺮﯾﻘﺔ ﺗﺤﺎﻛﻲ ﻧﻔﺲ ﻧﻤﻂ ‪.MySQL‬‬
‫ﺑﺎﻟﻀﻐﻂ ﻋﻠﻰ اﻟﻤﻠﻒ اﻟﺘﻨﻔﯿﺬي ‪ ،xampp-content.exe‬اﻟﻤﺆﺷﺮ ﺑﺎﻟﺴﮭﻢ اﻷﺣﻤﺮ‪ ،‬ﯾﺘﻢ ﻓﺘﺢ ﻟﻮﺣﺔ اﻟﺘﺤﻜﻢ واﻟﺘﻲ ﺗﺴﻤﺢ ﻟﻠﻤﺴﺘﺨﺪم ﺑﺘﺸﻐﯿﻞ‬
‫ﺧﺎدم اﻟﻮﯾﺐ ‪ Apache‬وﺑﺎﻟﺘﺎﻟﻲ ﺗﺠﺰﺋﺔ وﺗﻌﺮﯾﺐ ‪ parse‬ﻛﻮد ﻟﻐﺔ ‪ ،PHP‬وﻛﺬﻟﻚ ﺗﻄﺒﯿﻖ ‪ MariaDB‬أو ‪ .MySQL‬أﻧﻘﺮ زر ‪start‬‬
‫اﻟﻤﺸﺎر إﻟﯿﮫ ﺑﺪاﺋﺮة ﺑﺎﻟﻠﻮن اﻷﺧﻀﺮ ﻟﺘﺸﻐﯿﻞ ﺧﺎدم اﻟﻮﯾﺐ ‪ Apache‬وﻛﺬﻟﻚ زر ﺗﺸﻐﯿﻞ ﻗﻮاﻋﺪ اﻟﺒﯿﺎﻧﺎت ‪.MariaDB‬‬
‫واﻟﻨﺎﺗﺞ ﯾﺠﺐ أن ﯾﻜﻮن ﻛﻤﺎ ﻓﻲ اﻟﺼﻮرة اﻟﺘﺎﻟﯿﺔ‪:‬‬
‫ﻟﻠﺘﺄﻛﺪ ﻣﻦ أن اﻟﺨﺎدم ﯾﻌﻤﻞ ﺑﺼﻮرة ﺻﺤﯿﺤﺔ‪ ،‬ﻣﻦ ﺧﻼل ﻣﺘﺼﻔﺢ اﻻﻧﺘﺮﻧﺖ )ﻣﺜﻼ ‪ ،(Google Chrome‬اطﻠﺐ اﻟﻤﻮﻗﻊ ‪ ،localhost‬ﺛﻢ‬
‫اﺧﺘﺎر اﻟﻠﻐﺔ اﻻﻧﺠﻠﯿﺰﯾﺔ‪ ،‬ﻓﯿﺠﺐ أن ﺗﻈﮭﺮ ﻣﻌﻚ اﻟﺼﻔﺤﺔ اﻟﺘﺎﻟﯿﺔ‪:‬‬
‫ﺛﺎﻟﺜﺎ‪ :‬اﻟﺒﺮﻧﺎﻣﺞ اﻷول‬
‫ﻟﻜﺘﺎﺑﺔ اﻟﺒﺮﻧﺎﻣﺞ اﻷول ﺑﻠﻐﺔ ‪ ،PHP‬ﻻ ﺑﺪ ﻣﻦ ﻓﮭﻢ ﻣﺒﺎدئ ھﺬه اﻟﻠﻐﺔ‪ .‬إن ﺗﻌﻠﯿﻤﺎت ‪ script‬ﻛﻮد ﻣﻜﺘﻮب ﺑﻠﻐﺔ ‪ ،PHP‬ﯾﻤﻜﻦ أن ﺗﻮﺿﻊ ﻓﻲ‬
‫أي ﻣﻮﺿﻊ ﻓﻲ اﻟﻤﺴﺘﻨﺪ‪ ،‬وﯾﺠﺐ أن ﯾﺒﺪأ اﻟﺴﻜﺮﯾﺒﺖ ﺑﺎﻹﺷﺎرة ‪ <?php‬وﯾﻨﺘﮭﻲ ﺑﺎﻹﺷﺎرة >?‪ .‬وھﺬا ﻣﻦ أﺟﻞ اﻟﻤﺘﺼﻔﺢ اﻟﺬي ﺳﯿﻔﮭﻢ أن‬
‫ﺳﻜﺮﯾﺒﺖ اﻟﻜﻮد اﻟﻘﺎدم ھﻮ ﻣﻦ ﻧﻮع ‪ .PHP‬اﻟﺸﻜﻞ اﻟﻌﺎم ﻟﺴﻜﺮﯾﺒﺖ ‪ PHP‬ﻓﻲ اﻟﻤﺴﺘﻨﺪ‪ ،‬ﯾﻈﮭﺮ ﻛﻤﺎ ﯾﻠﻲ‪:‬‬
‫‪<?php‬‬
‫‪// PHP code goes here‬‬
‫>?‬
‫ﯾﺤﺘﻮي ﻣﻠﻒ ‪ PHP‬ﻋﺎدة ﻋﻠﻰ إﺷﺎرات ‪ HTML‬وﺗﻌﻠﯿﻤﺎت ﻛﻮد ‪ ،PHP‬ﻛﻤﺎ ﯾﻈﮭﺮ ﻓﻲ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ اﻟﺬي ﯾﺴﺘﺨﺪم دوال داﺧﻠﯿﺔ ﺟﺎھﺰة‬
‫‪ ،built-in‬واﺳﻢ اﻷوﻟﻰ ‪ echo‬ﻟﯿﺨﺮج ﻧﺺ ‪ hello world‬ﻓﻲ ﺻﻔﺤﺔ اﻟﻮﯾﺐ‪ ،‬واﺳﻢ اﻟﺜﺎﻧﯿﺔ ‪ print‬وﻟﮭﺎ ﻧﻔﺲ ﻋﻤﻞ اﻷوﻟﻰ‪ .‬ﯾﻤﻜﻦ أن‬
‫ﯾﺘﻢ إدﺧﺎل إﺷﺎرات ‪ HTML‬ﻹﺧﺮاﺟﮭﺎ ﻓﻲ ﺻﻔﺤﺔ اﻟﻮﯾﺐ ﻟﻠﻤﺴﺘﺨﺪم أﯾﻀﺎ ﻣﺜﻞ ﺳﻄﺮ ﺟﺪﯾﺪ وطﺒﺎﻋﺔ اﻟﺠﻤﻠﺔ ‪ Hello Everybody‬ﺑﺨﻂ‬
‫ﻏﺎﻣﻖ‪ ،‬وإدﺧﺎل ﺳﻄﺮ ﺟﺪﯾﺪ‪ ،‬اﻟﺦ‪.‬‬
‫ﻣﻠﻒ ‪ex0.php‬‬
‫>‪<!DOCTYPE html‬‬
‫>‪<html> <body> <h1>First example written in PHP</h1‬‬
‫‪<?php‬‬
‫;"!‪echo "Hello World‬‬
‫>?‬
‫‪<?php‬‬
‫;">‪print "<br> <b> Comments are not executing </b‬‬
‫‪# This is a single-line comment‬‬
‫>?‬
‫>‪<br> <u> This is HTML text </u> <br‬‬

‫>‪</body> </html‬‬
‫ﺧ ّﺰن ھﺬا اﻟﻤﻠﻒ ﻋﻠﻰ ﻣﺠﻠﺪ ﺟﺪﯾﺪ ﺑﺎﺳﻢ ‪ tutorial‬داﺧﻞ ﻣﺠﻠﺪ ‪ xampp‬وذﻟﻚ ﻋﻠﻰ ﻣﺠﻠﺪ ‪ htdocs‬ﻛﻤﺎ ﯾﻠﻲ‪:‬‬
‫‪C:\xampp\htdocs\xampp\tutorial‬‬
‫ﻣﻼﺣﻈﺔ‪ :‬ﻋﺰﯾﺰي اﻟﺪارس‪ ،‬إن ﻟﻢ ﯾﻜﻦ اﻟﺘﻄﺒﯿﻖ ‪ xampp‬ﻣﻔﺘﻮح‪ ،‬اﻓﺘﺤﮫ ﺛﻢ ﺷﻐﻞ ﺧﺎدم اﻟﻮﯾﺐ ‪.Apache‬‬
‫اﻵن وﻣﻦ ﺧﻼل اﻟﻤﺘﺼﻔﺢ ﻧﻔﺬ اﻟﻤﻠﻒ ‪ ،ex0.php‬وﺗﺄﻛﺪ ﻣﻦ أن اﻟﻨﺎﺗﺞ ھﻮ ﻛﻤﺎ ﯾﻠﻲ‪:‬‬
‫ﯾﺤﺘﻮي ﻣﻠﻒ ‪ PHP‬ﻋﺎدة ﻋﻠﻰ إﺷﺎرات ‪ HTML‬وﺗﻌﻠﯿﻤﺎت ﻛﻮد ‪ ،PHP‬ﻛﻤﺎ ﯾﻈﮭﺮ ﻓﻲ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ اﻟﺬي ﯾﺴﺘﺨﺪم دوال داﺧﻠﯿﺔ ﺟﺎھﺰة‬
‫‪ ،built-in‬واﺳﻢ اﻷوﻟﻰ ‪ echo‬ﻟﯿﺨﺮج ﻧﺺ ‪ hello world‬ﻓﻲ ﺻﻔﺤﺔ اﻟﻮﯾﺐ‪ ،‬واﺳﻢ اﻟﺜﺎﻧﯿﺔ ‪ print‬وﻟﮭﺎ ﻧﻔﺲ ﻋﻤﻞ اﻷوﻟﻰ‪ .‬ﯾﻤﻜﻦ أن‬
‫ﯾﺘﻢ إدﺧﺎل إﺷﺎرات ‪ HTML‬ﻹﺧﺮاﺟﮭﺎ ﻓﻲ ﺻﻔﺤﺔ اﻟﻮﯾﺐ ﻟﻠﻤﺴﺘﺨﺪم أﯾﻀﺎ ﻣﺜﻞ ﺳﻄﺮ ﺟﺪﯾﺪ وطﺒﺎﻋﺔ ﺟﻤﻠﺔ ﺑﺨﻂ ﻏﺎﻣﻖ‪ ،‬وإدﺧﺎل ﺳﻄﺮ‬
‫ﺟﺪﯾﺪ‪ ،‬اﻟﺦ ‪ .‬ﻓﻔﻲ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ‪ ،‬وﻛﻤﺎ ﺗﻼﺣﻆ‪ ،‬ﺗﻨﺘﮭﻲ ﺟﻤﻞ ‪ PHP‬ﺑﻔﺎﺻﻠﺔ ﻣﻨﻘﻮطﺔ ‪ ،semicolon‬وﯾﻤﻜﻦ دﻣﺞ إﺷﺎرات ‪،HTML‬‬
‫داﺧﻞ ﻛﻮد ‪ .PHP‬ﺣﯿﺚ ﺗﻢ إظﮭﺎر اﻟﻨﺺ ‪ Comments are not executing‬ﺑﺨﻂ ﻏﺎﻣﻖ وﺗﻢ أﯾﻀﺎ إظﮭﺎر اﻟﺠﻤﻠﺔ ﻓﻲ ﺳﻄﺮ ﺟﺪﯾﺪ‪.‬‬
‫ﯾﺴﺘﻌﻤﻞ اﻟﺘﻌﻠﯿﻖ ﻓﻲ اﻟﺒﺮﻣﺠﺔ ﻣﻦ أﺟﻞ ﺗﻮﺿﯿﺢ ﺗﻌﻠﯿﻤﺎت ﻣﻌﯿﻨﺔ أو ﺟﻤﻞ ﻣﻌﯿﻨﺔ داﺧﻞ اﻟﻜﻮد‪ ،‬وھﺬه اﻟﺘﻌﻠﯿﻘﺎت ﻻ ﺗﻨﻔﺬ طﺒﻌﺎ‪ .‬ﻓﻲ ﻟﻐﺔ ‪،PHP‬‬
‫اﻟﺘﻌﻠﯿﻘﺎت ﯾﻤﻜﻦ أن ﺗﺘﻢ ﻣﻦ ﺧﻼل اﻟﺸﺮطﺘﯿﻦ ”‪ “//‬و اﻟﺴﻠﻢ ”‪ “#‬واﻟﻠﺘﺎن ﺗﺴﻤﺤﺎن ﺑﻜﺘﺎﺑﺔ ﺳﻄﺮ واﺣﺪ ﻣﻦ اﻟﺘﻌﻠﯿﻘﺎت‪ ،‬أو ﻣﻦ ﺧﻼل اﻟﺸﺮطﺔ‬
‫ﻣﻊ اﻟﻨﺠﻤﺔ واﻟﺘﻲ ﺗﺴﻤﺢ ﺑﻜﺘﺎﺑﺔ أﻛﺜﺮ ﻣﻦ ﺳﻄﺮ ﻣﻦ اﻟﺘﻌﻠﯿﻘﺎت ﻛﻤﺎ ﻓﻲ ﻟﻐﺔ ‪ ،C‬وﻟﻐﺔ ‪C++‬‬
‫راﺑﻌﺎ‪ :‬اﻟﻤﺘﻐﯿﺮات ‪Variables‬‬

‫ﻓﻲ ﻟﻐﺔ ‪ ،PHP‬ﻓﺈن ﺟﻤﯿﻊ اﻟﻜﻠﻤﺎت اﻟﻤﺤﺠﻮزة ‪ ،keywords‬واﻷﺻﻨﺎف واﻟﺪوال ھﻲ ‪ ،not case-sensitive‬أي أن أﺳﻢ اﻟﺪاﻟﺔ ‪Print‬‬
‫أو ‪ PrinT‬أو ‪ ،PRINT‬ھﻲ ﺟﻤﯿﻌﮭﺎ ﺗﺴﺘﺪﻋﻲ اﻟﺪاﻟﺔ ‪ print‬اﻟﺴﺎﺑﻘﺔ‪ .‬أﻣﺎ اﻟﻤﺘﻐﯿﺮات ﻓﮭﻲ ‪ .case-sensitive‬ﻓﻤﺜﻼ اﻟﻤﺘﻐﯿﺮ ‪ x‬واﻟﺬي‬
‫ﯾﺤﻤﻞ ﻧﻮع اﻟﺒﯿﺎﻧﺎت ﺻﺤﯿﺢ ‪ ،integer‬ﯾﺨﺘﻠﻒ ﻋﻦ اﻟﻤﺘﻐﯿﺮ ‪ X‬واﻟﺬي ﯾﺤﻤﻞ ﻧﻮع اﻟﺒﯿﺎﻧﺎت ﻧﻘﻄﺔ ﻋﺎﺋﻤﺔ ‪.float‬‬
‫>‪<html><body> <h1>Variables in PHP</h1‬‬
‫‪<?php‬‬
‫;"‪$str = "Defining String Variable‬‬
‫;‪$x = 5‬‬
‫;‪$X = 3.14‬‬
‫;">‪prinT "$str in PHP<br‬‬
‫;‪ecHo $x + $X‬‬
‫;">‪echo "<br‬‬
‫;"!" ‪echo "I am " . $str .‬‬
‫>?‬
‫>‪</body> </html‬‬
‫اﻵن وﻣﻦ ﺧﻼل اﻟﻤﺘﺼﻔﺢ ﻧﻔﺬ اﻟﻤﻠﻒ ‪ ،ex1.php‬وﺗﺄﻛﺪ ﻣﻦ أن اﻟﻨﺎﺗﺞ ھﻮ ﻛﻤﺎ ﯾﻠﻲ‪:‬‬
‫ﻛﻤﺎ ﺗﻼﺣﻆ ﻋﺰﯾﺰي اﻟﺪارس‪ ،‬ﯾﻤﻜﻦ ﺗﻌﺮﯾﻒ ﻣﺘﻐﯿﺮ ﻓﻲ ﻟﻐﺔ ‪ PHP‬ﺑﺎﺳﺘﺨﺪام إﺷﺎرة ‪ $‬ﻣﺘﺒﻮﻋﺔ ﺑﺎﺳﻢ اﻟﻤﺘﻐﯿﺮ واﻟﺬي ﯾﺠﺐ أن ﯾﺒﺪأ ﺑﺤﺮف‬
‫أو ‪ .underscore‬وﯾﻤﻜﻦ ﻟﺼﻖ أﻛﺜﺮ ﻣﻦ ﺳﻠﺴﻠﺔ ﺑﺎﺳﺘﺨﺪام اﻟﻌﺎﻣﻞ )‪ (.‬ﻛﻤﺎ ﻓﻲ اﻟﺘﻌﻠﯿﻤﺔ اﻷﺧﯿﺮة ﻣﻦ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ‪ .‬ﻛﺬﻟﻚ ﻓﺈﻧﻨﺎ ﻟﻢ ﻧﺨﺒﺮ‬
‫ﻟﻐﺔ ‪ PHP‬ﺑﻨﻮع اﻟﺒﯿﺎﻧﺎت اﻟﺬي ﯾﺤﻤﻠﮫ اﻟﻤﺘﻐﯿﺮ‪ ،‬وذﻟﻚ ﻷن ﻟﻐﺔ ‪ PHP‬ﺗﻘﻮم ﺑﺘﺤﻮﯾﻞ اﻟﻤﺘﻐﯿﺮ ﺑﺸﻜﻞ أوﺗﻮﻣﺎﺗﯿﻜﻲ إﻟﻰ ﻧﻮع اﻟﺒﯿﺎﻧﺎت اﻟﻤﻨﺎﺳﺐ‬
‫ﺑﻨﺎء ﻋﻠﻰ ﻗﯿﻤﺘﮫ‪ .‬ﻓﻤﺜﻼ اﻟﻜﻮد اﻟﺘﺎﻟﻲ ﯾﻤﻜﻦ اﺳﺘﺨﺪاﻣﮫ ﻟﻤﻌﺮﻓﺔ ﻧﻮع اﻟﺒﯿﺎﻧﺎت اﻟﺬي ﯾﺤﻤﻠﮫ اﻟﻤﺘﻐﯿﺮ ﻣﻦ ﺧﻼل اﻟﺪاﻟﺔ اﻟﺠﺎھﺰة ‪:var_dump‬‬
‫>‪<html><body‬‬
‫‪<?php‬‬
‫;‪$x = 379.999‬‬
‫;)‪var_dump($x‬‬
‫;">‪echo "<br‬‬
‫;‪$x = 29‬‬
‫;)‪var_dump($x‬‬
‫>?‬
‫>‪</body></html‬‬
‫وﺗﻜﻮن اﻟﻨﺘﯿﺠﺔ ﻛﻤﺎ ﯾﻠﻲ‪:‬‬
‫)‪float(379.999‬‬
‫)‪int(29‬‬
‫ﻟﺘﻌﺮﯾﻒ ﻣﺘﻐﯿﺮ ﻣﻦ ﻧﻮع ﻣﺼﻔﻮﻓﺔ‪ ،‬ﻧﺴﺘﺨﺪم اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة ‪ ،array‬واﻟﺘﻲ ﺗﻤﻜﻨﻨﺎ ﻣﻦ ﺗﻌﺮﯾﻒ ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﻌﻨﺎﺻﺮ ﺗﺤﻤﻞ ﻧﻔﺲ ﻧﻮع‬
‫اﻟﺒﯿﺎﻧﺎت‪ .‬اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ﯾﻮﺿﺢ ﺗﻌﺮﯾﻒ ﻣﺼﻔﻮﻓﺔ ﺗﺤﻤﻞ ﺛﻼﺛﺔ ﻋﻨﺎﺻﺮ ﻣﻦ ﻧﻮع ﺳﻠﺴﻠﺔ ‪ ،string‬ﺣﯿﺚ ﯾﺘﻢ طﺒﺎﻋﺔ ﻋﻨﺎﺻﺮ اﻟﻤﺼﻔﻮﻓﺔ‬
‫ووﺻﻞ ﺗﻠﻚ اﻟﻌﻨﺎﺻﺮ ﺑﻌﻀﮭﺎ ﺑﺒﻌﺾ ﺑﺎﻹﺿﺎﻓﺔ إﻟﻰ ﺳﻼﺳﻞ أﺧﺮى ﻣﻦ ﺧﻼل اﻟﻌﺎﻣﻞ )‪ (.‬ﻛﻤﺎ ﺗﻢ ﺗﻮﺿﯿﺤﮫ ﺳﺎﺑﻘﺎ‪.‬‬
‫‪<?php‬‬
‫;)"‪$courses = array("Web Design", "Network Programming", "Distributed Systems‬‬
‫;"‪echo "This semester, I have three courses: " . $courses[0] . ", " . $courses[1] . " and " . $courses[2] . ".‬‬
‫;">‪echo "<br‬‬
‫;)‪$arrayLength = count($courses‬‬
‫)‪for($i = 0; $i < $arrayLength; $i++‬‬
‫{‬
‫;]‪echo $courses[$i‬‬
‫;">‪echo "<br‬‬
‫}‬
‫>?‬
‫ھﻨﺎك ﻧﻮع ﻣﻦ اﻟﻤﺼﻔﻮﻓﺎت وھﻲ اﻟﻤﺼﻔﻮﻓﺎت اﻟﻤﺘﺰاﻣﻠﺔ )ﻣﻦ زﻣﯿﻞ( ﺗﺴﻤﻰ ‪ ،associative arrays‬ﺗﺤﻮي ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﻌﻨﺎﺻﺮ‬
‫اﻟﻤﺘﺰاﻣﻠﺔ ﻣﻊ ﻗﯿﻤﮭﺎ‪ ،‬أي أن ﻟﻜﻞ ﻋﻨﺼﺮ ﻓﻲ اﻟﻤﺼﻔﻮﻓﺔ زﻣﯿﻞ واﺣﺪ ﻣﻦ اﻟﻘﯿﻢ اﻟﻤﻘﺎﺑﻠﺔ ﻟﮫ‪ .‬ھﻨﺎك طﺮﯾﻘﺘﯿﻦ ﻟﺘﻌﺮﯾﻒ اﻟﻤﺼﻔﻮﻓﺔ اﻟﻤﺘﺰاﻣﻠﺔ‪،‬‬
‫اﻷوﻟﻰ ﺑﺎﺳﺘﺨﺪام اﻟﻜﻠﻤﺔ اﻟﻤﻔﺘﺎح ‪:array‬‬
‫;)"‪$price = array("BMW"=>"35000", "VW"=>"32000", "Opel"=>"24000‬‬
‫واﻟﺜﻨﯿﺔ ﺑﺎﺳﺘﺨﺪام اﻟﺘﻌﺮﯾﻒ اﻟﻤﻨﻔﺮد ﻟﻜﻞ ﻋﻨﺼﺮ‪:‬‬
‫;"‪$price['BMW'] = "35000‬‬
‫;"‪$price['VW'] = "32000‬‬
‫;"‪$price['Opel'] = "24000‬‬
‫اﻵن ﯾﻤﻜﻦ اﺳﺘﺨﺪام أﺣﺪ اﻟﻌﻨﺎﺻﺮ وﻣﺎ ﯾﻘﺎﺑﻠﮫ ﻣﻦ ﻗﯿﻤﺔ ﺑﺎﺳﺘﺨﺪام اﻟﺴﻜﺮﯾﺒﺖ اﻟﺘﺎﻟﻲ‪:‬‬
‫;"‪echo "Price of Opel is " . $price['Opel'] . " USD.‬‬
‫أو ﻣﻦ ﺧﻼل ﺟﻤﻠﺔ دوران‪ ،‬ﺣﯿﺚ ﯾﺘﻢ ﺗﻌﺮﯾﻒ ﻣﺘﻐﯿﺮ ﻣﺜﻞ ‪ x‬ﯾﻤﺜﻞ اﻟﻌﻨﺼﺮ‪ ،‬وﻣﺘﻐﯿﺮ آﺧﺮ ﻣﺜﻞ ‪ x_value‬ﯾﻤﺜﻞ اﻟﻘﯿﻤﺔ اﻟﻤﻘﺎﺑﻠﺔ )اﻟﺰﻣﯿﻠﺔ(‪،‬‬
‫ﻛﻤﺎ ھﻮ ﻣﻮﺿﺢ ﻓﻲ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ‪:‬‬
‫‪<?php‬‬
‫;)"‪$price = array("BMW"=>"35000", "VW"=>"32000", "Opel"=>"24000‬‬
‫)‪foreach($price as $x => $x_value‬‬
‫{‬
‫;‪echo "Model= " . $x . ", Price= " . $x_value‬‬
‫;">‪echo "<br‬‬
‫}‬
‫>?‬
‫ﺧﺎﻣﺴﺎ‪ :‬اﻟﺪوال ‪Functions‬‬

‫ﻟﻘﺪ ﺗﻌﺮﻓﻨﺎ ﻋﻠﻰ ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﺪوال اﻟﺠﺎھﺰة أو اﻟﻤﺒﻨﯿﺔ ‪ built-in‬ﻓﻲ ﻟﻐﺔ ‪ ،PHP‬وﻣﻨﮭﺎ ‪ print‬و ‪ .echo‬ﻓﻲ ھﺬا اﻟﺠﺰء‪ ،‬ﺳﻨﺘﻌﺮف‬
‫ﻋﻠﻰ اﻟﺪوال اﻟﺮﯾﺎﺿﯿﺔ اﻟﻤﺒﻨﯿﺔ ﻓﻲ اﻟﻠﻐﺔ واﻟﺘﻲ ﺗﺨﺘﺺ ﺑﺎﻟﺮﯾﺎﺿﯿﺎت‪ ،‬وﻛﺬﻟﻚ ﻋﻠﻰ طﺮﯾﻘﺔ إﻧﺸﺎء واﺳﺘﺪﻋﺎء اﻟﺪوال ﻣﻦ ﻗﺒﻞ اﻟﻤﺴﺘﺨﺪم‪.‬‬
‫اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ﯾﻮﺿﺢ طﺮﯾﻘﺔ اﺳﺘﺨﺪام ﺑﻌﺾ دوال اﻟﺮﯾﺎﺿﯿﺎت‪ .‬ﻓﯿﻤﻜﻦ إﯾﺠﺎد اﻟﻘﯿﻤﺔ اﻟﻤﻄﻠﻘﺔ ﻟﻌﺪد ﻣﻌﯿﻦ ﺑﺎﺳﺘﺨﺪام اﻟﺪاﻟﺔ ‪ ،abs‬وأﺳﺲ‬
‫اﻷﻋﺪاد اﻟﺼﺤﯿﺤﺔ ﺑﺎﺳﺘﺨﺪام اﻟﺪاﻟﺔ ‪ ،pow‬واﻟﺪاﻟﺔ اﻷﺳﯿﺔ ﺑﺎﺳﺘﺨﺪام ‪ ،exp‬وﻟﻮﻏﺎرﯾﺘﻢ ﻋﺪد ﺑﺎﺳﺘﺨﺪام اﻟﺪاﻟﺔ ‪ ،log10‬واﻟﺘﻘﺮﯾﺐ ﺑﺎﺳﺘﺨﺪام‬
‫‪ ،round‬وأﻗﻞ ﻋﺪد ﺻﺤﯿﺢ ﻟﻌﺪد ﻛﺴﺮي ﺑﺎﺳﺘﺨﺪام ‪ ،floor‬وأﻛﺒﺮ ﻋﺪد ﺻﺤﯿﺢ ﻟﻌﺪد ﻛﺴﺮﯾﺔ ﺑﺎﺳﺘﺨﺪام ‪ .ceil‬أﻣﺎ ﺟﯿﺐ اﻟﺰاوﯾﺔ ‪sin‬‬
‫وﺟﯿﺐ ﺗﻤﺎﻣﮭﺎ ‪ ،cos‬ﻓﯿﺄﺧﺬان زاوﯾﺔ ﺑﺎل ‪ radians‬وﯾﻌﯿﺪان ﻗﯿﻤﺘﮭﺎ ﻋﻠﻰ ﺷﻜﻞ ﻗﯿﻤﺔ ﻧﻘﻄﺔ ﻋﺎﺋﻤﺔ ‪.floating point value‬‬
‫ﺑﻤﺴﺎﻋﺪة ﻣﺸﺮﻓﻚ اﻷﻛﺎدﯾﻤﻲ‪ ،‬ﻧﻔﺬ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ﻋﻠﻰ ﺟﮭﺎز اﻟﺤﺎﺳﻮب‪ ،‬وﺣﺎول أن ﺗﺘﻌﺮف ﻋﻠﻰ آﻟﯿﺔ ﻋﻤﻞ اﻟﺪوال اﻟﺮﯾﺎﺿﯿﺔ‪.‬‬
‫>‪<html><body><h2>Mathematical Functions in PHP</h2‬‬
<?php
echo "absolute value of -3.6 is: ";
echo(abs(-3.6) ."<br>");
echo "power of two integers is: ";
echo(pow(2,-4) . "<br>");
echo "exponential of float value is: ";
echo(exp(3.46) . "<br>");
echo "log to base 10 of 10 is: ";
echo(log10(10) . "<br>");
echo "log to base 10 of 6.61 is: ";
echo(log10(6.61) . "<br>");
echo "log to base 10 of 0 is: ";
echo(log10(0) . "<br>");
echo "round of 1.8 is: ";
echo(round(1.80) ."<br>");
echo "round of -4.40 is: ";
echo(round(-4.40) ."<br>");
echo "floor of 0.50 is: ";
echo(floor(0.50) . "<br>");
echo "floor of 7.1 is: ";
echo(floor(7.1) . "<br>");
echo "floor of -7.7 is: ";
echo(floor(-7.7) . "<br>");
echo "ceil of 0.50 is: ";
echo(ceil(0.50) . "<br>");
echo "ceil of 5.1 is: ";
echo(ceil(5.1) . "<br>");
echo "ceil of -5.9 is: ";
echo(ceil(-5.9) . "<br>");
echo "sine of 180 degrees is: ";
echo(sin(M_PI) . "<br>");
echo "cosine of 0 degrees is: ";
echo(cos(0) . "<br>");
echo "cosine of 45 degrees is: ";
echo(cos(M_PI/4.0) . "<br>");
?>
</body></html>
:‫وﯾﻜﻮن ﻧﺎﺗﺞ اﻟﺘﻨﻔﯿﺬ ﻛﻤﺎ ﯾﻠﻲ‬
‫ﺑﺠﺎﻧﺐ اﺣﺘﻮاء ﻟﻐﺔ ‪ PHP‬ﻋﻠﻰ آﻻف اﻟﺪوال اﻟﻤﺒﻨﯿﺔ ﻣﺴﺒﻘﺎ ‪ ،built-in‬ﯾﻤﻜﻦ ﻟﻠﻤﺒﺮﻣﺞ أن ﯾﻌﺮف اﻟﺪاﻟﺔ اﻟﺨﺎﺻﺔ ﺑﮫ ﻟﺘﻘﻮم ﺑﺒﻌﺾ‬
‫اﻟﻤﮭﻤﺎت‪ .‬ﻓﺎﻟﺪاﻟﺔ ﻓﻲ ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ ﺑﺸﻜﻞ ﻋﺎم ھﻲ ﺑﻠﻮك ﯾﺤﻮي ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﺠﻤﻞ اﻟﺒﺮﻣﺠﯿﺔ‪ ،‬وھﺬا اﻟﺒﻠﻮك ﯾﺘﻢ اﺳﺘﺪﻋﺎؤه ﻟﻠﺘﻨﻔﯿﺬ ﻋﺪة‬
‫ﻣﺮات أﺛﻨﺎء ﻋﻤﻞ اﻟﺒﺮﻧﺎﻣﺞ وذﻟﻚ ﺑﺤﺴﺐ اﻟﺤﺎﺟﺔ‪ .‬ﻓﺒﺪﻻ ﻣﻦ ﻛﺘﺎﺑﺔ ﻧﻔﺲ اﻟﻜﻮد ﻋﺪة ﻣﺮات‪ ،‬ﯾﺘﻢ وﺿﻊ ذﻟﻚ اﻟﻜﻮد ﻓﻲ داﺧﻞ ﺑﻠﻮك ﯾﺴﻤﻰ‬
‫‪ ،function‬وﯾﺘﻢ اﺳﺘﺪﻋﺎؤه ﻋﻨﺪ اﻟﺤﺎﺟﺔ ﻟﻠﺘﻨﻔﯿﺬ‪ .‬ﺗﻌﻠﯿﻤﺎت ﻛﻮد اﻟﺪاﻟﺔ ﻻ ﯾﺘﻢ ﺗﻨﻔﯿﺬھﺎ ﻋﻨﺪ ﺗﺤﻤﯿﻞ اﻟﺼﻔﺤﺔ‪ ،‬وﻟﻜﻦ ﻋﻨﺪﻣﺎ ﯾﺘﻢ اﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ‪.‬‬
‫ﻓﻲ اﻟﺸﻜﻞ اﻟﻌﺎم اﻟﺘﺎﻟﻲ ﻟﺘﻌﺮﯾﻒ اﻟﺪاﻟﺔ‪ ،‬وﻛﻤﺎ ﺗﺮى‪ ،‬ﻋﺰﯾﺰي اﻟﺪارس‪ ،‬ﻓﺈن اﻟﺘﺼﺮﯾﺢ ﺑﺎﻟﺪاﻟﺔ ﯾﺘﻢ ﻣﻦ ﺧﻼل اﻟﻜﻠﻤﺔ اﻟﻤﻔﺘﺎﺣﯿﺔ ‪.function‬‬
‫اﺳﻢ اﻟﺪاﻟﺔ ﯾﺒﺪأ ﺑﺤﺮف أو ) _ (‪ ،‬وﻟﻜﻦ ﻻ ﯾﻤﻜﻦ أن ﯾﺒﺪأ ﺑﺮﻗﻢ‪.‬‬
‫)(‪function functionName‬‬
‫{‬
‫;‪//code to be executed‬‬
‫}‬
‫ﻓﻲ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ‪ ،‬ﺳﺘﻜﺘﺐ داﻟﺔ‪ ،‬ﺗﻌﻤﻞ ﻋﻠﻰ طﺒﺎﻋﺔ ﺟﻤﻠﺔ ﻓﻲ اﻟﻤﺘﺼﻔﺢ‪.‬‬
‫>‪<html><body><h2>User-defined Function in PHP</h2‬‬
‫‪<?php‬‬
‫;“ ‪echo “2 power to 4 is:‬‬
‫;)”>‪echo(pow(2, 4) . “<br‬‬
‫)(‪function writeMessageToBrowser‬‬
‫{‬
‫;”>‪echo “<br>I am learning functions of PHP <br‬‬
‫}‬
‫;“ ‪echo “<br>sine of 90 degrees is:‬‬
‫;)”>‪echo(sin(M_PI/2.0) . “<br‬‬
‫‪writeMessageToBrowser(); // call the function‬‬
‫;”‪echo “<br>End‬‬
‫>?‬
‫وﺗﻜﻮن اﻟﻨﺘﯿﺠﺔ ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬
‫وﻛﻤﺎ ﺗﺮى ﻋﺰﯾﺰي اﻟﺪارس‪ ،‬ﯾﺠﺐ اﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ ﻣﻦ أﺟﻞ اﻟﺘﻨﻔﯿﺬ‪ .‬ﻓﻘﺪ ﺗﻢ ﺗﻨﻔﯿﺬ ﺗﻌﻠﯿﻤﺎت ‪ script‬ﻧﺎﺗﺞ ‪ 2‬ﻟﻠﻘﻮة ‪ ،4‬وﻟﻜﻦ ﻟﻢ ﯾﺘﻢ ﺗﻨﻔﯿﺬ‬
‫ﺗﻌﻠﯿﻤﺎت اﻟﺪاﻟﺔ‪ ،‬ﻓﻘﻔﺰ ﻋﻦ اﻷﺳﻄﺮ اﻟﺨﺎﺻﺔ ﺑﮭﺎ‪ ،‬ﺣﯿﺚ ﻗﺎم ﺑﺘﻨﻔﯿﺬ ﺗﻌﻠﯿﻤﺎت إﯾﺠﺎد ﺟﯿﺐ زاوﯾﺔ ‪ 90‬درﺟﺔ‪ ،‬ﺑﻌﺪ ذﻟﻚ ﺻﺎدف وﺟﻮد ﺗﻌﻠﯿﻤﺔ‬
‫ﺗﺴﺘﺪﻋﻲ اﻟﺪاﻟﺔ‪ ،‬ﻓﻘﺎم ﺑﺘﻨﻔﯿﺬ ﺗﻌﻠﯿﻤﺎت اﻟﺪاﻟﺔ‪ ،‬ﺛﻢ ﻋﺎد ﯾﻨﻔﺬ أﺧﺮ ﺗﻌﻠﯿﻤﺔ ﻓﻲ اﻟﺒﺮﻧﺎﻣﺞ وھﻲ طﺒﺎﻋﺔ اﻟﻜﻠﻤﺔ ‪.End‬‬
‫ﻓﻲ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ‪ ،‬ﻋﺰﯾﺰي اﻟﺪارس‪ ،‬ﺳﻮف ﺗﻜﺘﺐ داﻟﺔ‪ ،‬ﺗﺄﺧﺬ ﻣﺘﻐﯿﺮﯾﻦ ‪ ،two parameters‬اﻟﻤﺘﻐﯿﺮ اﻷول أﺳﻢ اﻟﻌﺎﺋﻠﺔ ‪،familyName‬‬
‫واﻟﻤﺘﻐﯿﺮ اﻟﺜﺎﻧﻲ اﻟﻌﻼﻣﺔ ‪ ،Mark‬ﺣﯿﺚ ﺗﻌﻤﻞ ھﺬه اﻟﺪاﻟﺔ ﻋﻠﻰ ﻛﺘﺎﺑﺔ ﻣﻌﻠﻮﻣﺎت ﻋﻦ اﻟﻄﺎﻟﺐ ﻓﻲ اﻟﻤﺘﺼﻔﺢ‪.‬‬
‫>‪<html><body><h2>User-defined Functions in PHP</h2‬‬
‫‪<?php‬‬
‫;">‪echo "User-defined Function with Arguments<br‬‬
‫)‪function studentInformation($FamilyName, $Mark‬‬
‫{‬
‫;">‪echo "$FamilyName, his mark is $Mark <br‬‬
‫}‬
‫;)"‪studentInformation("Ahmad","86‬‬
‫;)"‪studentInformation("Mohammad","88‬‬
‫;)"‪studentInformation("Abdallah","71‬‬
‫>?‬
‫ﻻﺣﻆ ﻋﺰﯾﺰي اﻟﺪارس‪ ،‬أﻧﮫ ﺗﻢ ﻣﻨﺎداة اﻟﺪاﻟﺔ ﺑﺎﺳﻤﮭﺎ ﻣﻊ ﺗﻤﺮﯾﺮ ﻣﻌﺎﻣﻠﯿﻦ ‪ ،two arguments‬ﻓﻲ ﻛﻞ ﻣﺮة‪ .‬وھﻤﺎ اﺳﻢ اﻟﻌﺎﺋﻠﺔ واﻟﻌﻼﻣﺔ‪.‬‬
ex8.php ‫ﻣﻠﻒ‬
‫ وﺗﻌﯿﺪ اﻟﻨﺎﺗﺞ إﻟﻰ‬،integers ‫ ﻣﻦ ﻧﻮع‬،two parameters ‫ ﺗﺄﺧﺬ ﻣﺘﻐﯿﺮﯾﻦ‬،‫ ﺳﻮف ﺗﻜﺘﺐ داﻟﺔ‬،‫ ﻋﺰﯾﺰي اﻟﺪارس‬،‫ﻓﻲ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ‬
.‫اﻟﻤﻨﺎدي ﻟﯿﻌﻤﻞ ﻋﻠﻰ ﻛﺘﺎﺑﺔ ﺣﺎﺻﻞ ﺟﻤﻊ اﻟﻌﺪدﯾﻦ ﻓﻲ اﻟﻤﺘﺼﻔﺢ‬
<!DOCTYPE html>
<html><body><h2>User-defined Functions in PHP</h2>
<?php
echo "User-defined Function with Parameters and Return Value<br><br>";
function Addition($number1, $number2)
{
$result = $number1 + $number2;
return $result;
}
echo "7 + 8 = " . Addition (7, 8)."<br>";

echo "7.3 + 8.6 = " . Addition (7.3, 8.6)."<br>";
echo "7 + -8 = " . Addition (7, -8)."<br>";
?>
</body></html>
‫ ﻓﻲ اﻟﻤﺮة اﻷوﻟﻰ وﻓﻲ اﻟﻤﺮة‬.‫ ﺛﻼث ﻣﺮات‬،two arguments ‫ أﻧﮫ ﺗﻢ ﻣﻨﺎداة اﻟﺪاﻟﺔ ﺑﺎﺳﻤﮭﺎ ﻣﻊ ﺗﻤﺮﯾﺮ ﻣﻌﺎﻣﻠﯿﻦ‬،‫ﻻﺣﻆ ﻋﺰﯾﺰي اﻟﺪارس‬
.floating point numbers ‫ وﻓﻲ اﻟﻤﺮة اﻟﺜﺎﻧﯿﺔ ﻛﺎﻧﺎ ﺑﻔﺎﺻﻠﺔ ﻋﺸﺮﯾﺔ‬،‫ ﻛﺎن اﻟﻤﻌﻤﻼن ﻋﺪدﯾﻦ ﺻﺤﯿﺤﯿﻦ‬،‫اﻟﺜﺎﻟﺜﺔ‬
ex9.php ‫ﻣﻠﻒ‬
‫ ھﻮ‬،‫ اﻟﻔﺮق ﺑﯿﻨﮭﻤﺎ‬.‫ واﻟﺜﺎﻧﯿﺔ أﯾﻀﺎ‬،one parameter ‫ اﻷوﻟﻰ ﺗﺄﺧﺬ ﻣﺘﻐﯿﺮ واﺣﺪ‬،‫ ﺳﻮف ﺗﻜﺘﺐ داﻟﺘﯿﻦ‬،‫ ﻋﺰﯾﺰي اﻟﺪارس‬،‫ﻓﻲ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ‬
.call by value or call by reference ‫ ﺗﻤﺮﯾﺮ ﺑﺎﻟﻘﯿﻤﺔ وﺗﻤﺮﯾﺮ ﺑﺎﻟﻤﺮﺟﻊ‬،‫أن ﻧﻮع اﻟﺘﻤﺮﯾﺮ‬
<!DOCTYPE html>
<html><body><h2>User-defined Functions in PHP</h2>
<?php
echo "Pass by Value or Pass by Reference<br><br>";
function add7($number1)
{
$number1 = $number1 + 7;
}
function add3(&$number2)
{
$number2 = $number2 + 3;
}
‫;‪$result = 9‬‬
‫;)‪Add7($result‬‬
‫;">‪echo "$result<br‬‬
‫;)‪Add3($result‬‬
‫;">‪echo "$result<br‬‬
‫>?‬
‫ﻻﺣﻆ ﻋﺰﯾﺰي اﻟﺪارس‪ ،‬أﻧﮫ ﺗﻢ ﻣﻨﺎداة ﻛﻞ داﻟﺔ ﺑﺎﺳﻤﮭﺎ ﻣﻊ ﺗﻤﺮﯾﺮ ﻣﻌﺎﻣﻞ ﻟﮭﺎ‪ .‬وﻟﻜﻦ ﻓﻲ اﻟﻤﺮة اﻷوﻟﻰ‪ ،‬ﻛﺎﻧﺖ اﻟﻤﻨﺎداة ﺑﺘﻤﺮﯾﺮ اﻟﻘﯿﻤﺔ‪ ،‬ﻓﻠﻢ‬
‫ﺗﺘﻐﯿﺮ اﻟﻘﯿﻤﺔ اﻷﺻﻠﯿﺔ‪ ،‬وﻓﻲ اﻟﻤﺮة اﻟﺜﺎﻧﯿﺔ ﻛﺎﻧﺖ اﻟﻤﻨﺎداة ﺑﺘﻤﺮﯾﺮ اﻟﻤﺮﺟﻊ‪ ،‬ﻓﺤﺼﻞ اﻟﺘﻐﯿﯿﺮ ﻋﻠﻰ اﻟﺮﻗﻢ اﻷﺳﺎس‪.‬‬
‫ﺳﺎدﺳﺎ‪ :‬ﻣﺠﺎل اﻟﻤﺘﻐﯿﺮات ‪Scope of Variables‬‬

‫إن ﻣﺠﺎل اﻟﻤﺘﻐﯿﺮات ‪ ،scope of variables‬ھﻮ اﻟﺠﺰء ﻣﻦ اﻟﺘﻌﻠﯿﻤﺎت اﻟﺬي ﯾﻤﻜﻨﮫ رؤﯾﺔ ذﻟﻚ اﻟﻤﺘﻐﯿﺮ‪ ،‬وﯾﻤﻜﻦ اﺳﺘﻌﻤﺎل ذﻟﻚ اﻟﻤﺘﻐﯿﺮ‬
‫ﻣﻦ ﻗﺒﻞ ﺗﻠﻚ اﻟﺘﻌﻠﯿﻤﺎت‪ .‬وﻟﻐﺔ ‪ PHP‬ﺗﻌﺮف ‪ 3‬ﻣﺠﺎﻻت وھﻲ اﻟﻤﺤﻠﻲ ‪ ،local‬واﻟﻌﺎم ‪ ،global‬واﻟﺜﺎﺑﺖ ‪ .static‬ﻓﺎﻟﻤﺘﻐﯿﺮ اﻟﺬي ﯾﻌﺮف‬
‫ﺧﺎرج اﻟﺪاﻟﺔ ﻟﮫ ﻣﺠﺎل رؤﯾﺔ ﻣﻦ ﻧﻮع ‪ ،Global‬وﻻ ﯾﻤﻜﻦ اﺳﺘﺨﺪاﻣﮫ ﻣﻦ داﺧﻞ اﻟﺪاﻟﺔ إﻻ إذا ﺗﻢ اﻟﺘﺼﺮﯾﺢ ﺑﻌﻤﻮﻣﯿﺘﮫ ﻣﻦ داﺧﻞ ﺗﻠﻚ اﻟﺪاﻟﺔ‪.‬‬
‫ﺑﺎﻟﺘﺎﻟﻲ‪ ،‬ﻓﺈن ﺗﻨﻔﯿﺬ اﻟﺒﺮﻧﺎﻣﺞ اﻟﺘﺎﻟﻲ ﯾﺆدي إﻟﻰ ﺧﻄﺄ ﺑﺴﺒﺐ ﻣﺤﺎوﻟﺔ اﺳﺘﺨﺪام ﻣﺘﻐﯿﺮ ﻓﻲ داﺧﻞ داﻟﺔ‪ ،‬ﻣﻊ اﻟﻌﻠﻢ أن ﺗﻢ ﺗﻌﺮﯾﻔﮫ ﻋﺎم ‪.global‬‬
‫>‪<html><body><h2>Global variable in PHP</h2‬‬
‫‪<?php‬‬
‫‪$x = 3; // global scope‬‬
‫)(‪function func1‬‬
‫{‬
‫;">‪echo "<p>Error using variable x inside function: $x</p‬‬
‫}‬
‫;)(‪func1‬‬
‫;">‪echo "<p>No Error: $x</p‬‬
‫>?‬
‫ﻣﺘﻐﯿﺮ ﺗﻢ ﺗﻌﺮﯾﻔﮫ داﺧﻞ اﻟﺪاﻟﺔ‪ ،‬ﻟﮫ ﻣﺠﺎل ﻣﺤﻠﻲ ‪ ،local scope‬وﯾﻤﻜﻦ اﺳﺘﺨﺪاﻣﮫ ﻓﻲ داﺧﻞ ﺗﻠﻚ اﻟﺪاﻟﺔ ﻓﻘﻂ‪ .‬ﻟﺬﻟﻚ ﻓﺈن ﺗﻨﻔﯿﺬ ﺳﻜﺮﯾﺒﺖ‬
‫‪ PHP‬اﻟﺘﺎﻟﻲ‪ ،‬ﺳﯿﺆدي إﻟﻰ ﺧﻄﺄ ﺑﺴﺒﺐ أن ﻣﺘﻐﯿﺮ ﺗﻢ ﺗﻌﺮﯾﻔﮫ داﺧﻞ داﻟﺔ‪ ،‬وﻟﻜﻦ اﻟﻤﺒﺮﻣﺞ ﯾﻌﻤﻞ ﻋﻠﻰ ﻣﺤﺎوﻟﺔ اﺳﺘﺨﺪاﻣﮫ ﻣﻦ ﺧﺎرﺟﮭﺎ‪.‬‬
‫>‪<html><body><h2>Local variables in PHP</h2‬‬
‫‪<?php‬‬
‫{‬
‫‪$x = 3; // local scope‬‬
‫;">‪echo "<p>No Error printing variable x inside the function: $x</p‬‬
‫}‬
‫;)(‪func2‬‬
‫;">‪echo "<p>Error accessing variable x outside the function: $x</p‬‬
‫>?‬
‫ﻣﺘﻐﯿﺮ ﺗﻢ ﺗﻌﺮﯾﻔﮫ ﺧﺎرج اﻟﺪاﻟﺔ‪ ،‬ﯾﻤﻜﻦ اﺳﺘﺨﺪاﻣﮫ ﻓﻲ داﺧﻞ اﻟﺪاﻟﺔ‪ ،‬وﻟﻜﻦ ﯾﺠﺐ أن ﯾﻮﺻﻒ ﺑﺄﻧﮫ ﻋﺎم ﻣﻦ ﺧﻼل اﻟﻜﻠﻤﺔ اﻟﻤﻔﺘﺎﺣﯿﺔ ‪،global‬‬
‫وذﻟﻚ ﻓﻲ داﺧﻞ اﻟﺪاﻟﺔ اﻟﺘﻲ ﺳﺘﺴﺘﺨﺪﻣﮫ‪ .‬ﻻ ﯾﻨﺘﺞ أﯾﺔ أﺧﻄﺎء ﻋﻨﺪ ﺗﻨﻔﯿﺬ اﻟﺴﻜﺮﯾﺒﺖ اﻟﺘﺎﻟﻲ‪:‬‬
‫>‪<html><body><h2>Global variables inside functions in PHP</h2‬‬
‫‪<?php‬‬
‫;‪$x = 5; $y = 7; $z = 0‬‬
‫{‬
‫;‪global $x, $y, $z‬‬
‫;‪$z = $x + $y‬‬
‫}‬
‫;)(‪func3‬‬
‫‪echo $z; // result is 12‬‬
‫>?‬
‫ﻋﻨﺪ اﻻﻧﺘﮭﺎء ﻣﻦ ﺗﻨﻔﯿﺬ داﻟﺔ ﻗﻤﻨﺎ ﺑﻜﺘﺎﺑﺘﮭﺎ‪ ،‬ﻓﺈن ﺟﻤﯿﻊ ﻣﺘﻐﯿﺮاﺗﮭﺎ اﻟﻤﺤﻠﯿﺔ ﺗﺤﺬف‪ .‬أﺣﯿﺎﻧﺎ‪ ،‬ﻧﺮﯾﺪ اﻻﺣﺘﻔﺎظ ﺑﺂﺧﺮ ﻗﯿﻤﺔ ﻟﻤﺘﻐﯿﺮ ﻣﺤﻠﻲ ﻣﻌﯿﻦ‪ ،‬وﻻ‬
‫ﻧﺮﯾﺪ أن ﯾﺘﻢ ﺣﺬﻓﮫ‪ ،‬ﻷﻧﻨﺎ ﻧﺮﯾﺪ اﺳﺘﺨﺪاﻣﮫ ﻻﺣﻘﺎ‪ .‬ﯾﺘﻢ اﻟﺘﺼﺮﯾﺢ ﺑﮭﺬا اﻟﻤﺘﻐﯿﺮ ﻋﻠﻰ أﻧﮫ ‪ static‬ﻋﻨﺪ ﺗﻌﺮﯾﻔﮫ‪ ،‬ﻛﻤﺎ ﯾﻠﻲ‪:‬‬
‫ﻣﻠﻒ ‪:ex10‬‬
‫>‪<html><body><h2>Static variables inside functions in PHP</h2‬‬
‫‪<?php‬‬
‫{‬
‫;‪static $x = 0‬‬
‫;‪echo $x‬‬
‫;">‪echo "<br‬‬
‫;‪$x++‬‬
‫}‬
‫;)( ‪func4‬‬
‫;)( ‪func4‬‬
‫;)( ‪func4‬‬
‫>?‬
‫وﯾﻜﻮن ﻧﺎﺗﺞ ﺗﻨﻔﯿﺬ اﻟﺒﺮﻧﺎﻣﺞ ﻛﻤﺎ ﯾﻠﻲ‪:‬‬
‫ﻓﻜﻤﺎ ﺗﻼﺣﻆ‪ ،‬ﺗﻢ اﻻﺣﺘﻔﺎظ ﺑﺎﻟﻘﯿﻤﺔ اﻟﻘﺪﯾﻤﺔ ﺛﻢ أﺿﺎف اﻟﻘﯿﻤﺔ اﻟﺠﺪﯾﺪة إﻟﯿﮭﺎ‪ ،‬ﻓﻜﺎﻧﺖ اﻟﺰﯾﺎدة ﺗﻈﮭﺮ ﻓﻲ ﻛﻞ ﻣﺮة‪ .‬ﻧﻔﺬ ﻋﺰﯾﺰي اﻟﺪارس‪ ،‬اﻟﻤﺜﺎل‬
‫اﻟﺴﺎﺑﻖ ﻣﻦ ﻏﯿﺮ اﻟﻜﻠﻤﺔ اﻟﻤﻔﺘﺎﺣﯿﺔ ‪ ،static‬ﺛﻢ ﻻﺣﻆ اﻟﻔﺮق‪.‬‬
‫اﻟﻨﺸﺎط اﻟﺼﻔﻲ اﻟﺮاﺑﻊ‬
‫أﺳﺎﺳﯿﺎت ﻗﻮاﻋﺪ اﻟﺒﯿﺎﻧﺎت ﺑﺎﺳﺘﺨﺪام‬

‫‪MySQL‬‬
‫ﻗﺎﻋﺪة اﻟﺒﯿﺎﻧﺎت ‪ ،database‬ھﻲ ﻋﺒﺎرة ﻋﻦ ﺗﺠﻤﯿﻊ ﻣﻨﻈﻢ ﻣﻦ اﻟﺒﯿﺎﻧﺎت‪ ،‬واﻟﺘﻲ ﻗﺪ ﺗﻜﻮن ﻋﻠﻰ ﺷﻜﻞ ﺟﺪاول ‪ ،tables‬أو اﺳﺘﻌﻼﻣﺎت‬
‫‪ ،queries‬أو ﺗﻘﺎرﯾﺮ ‪ ،reports‬أو ﺣﺘﻰ ﻣﺨﻄﻄﺎت ‪ .schemas‬ﯾﺘﻢ ﺗﻨﻈﯿﻢ اﻟﺒﯿﺎﻧﺎت ﺑﺤﯿﺚ ﺗﻌﻤﻞ ﻋﻠﻰ ﻧﻤﺬﺟﺔ ﺑﻌﺾ اﻟﺘﻄﺒﯿﻘﺎت اﻟﺤﯿﺔ‬
‫ﻣﺜﻞ اﻟﻤﺴﺎﻋﺪة ﻓﻲ ﺣﺠﺰ ﻏﺮﻓﺔ ﻓﺎرﻏﺔ ﻓﻲ ﻓﻨﺪق‪ .‬ﻓﻘﺪ ﺗﺸﻜﻞ ﻗﻮاﻋﺪ اﻟﺒﯿﺎﻧﺎت ﺟﺰءاً أﺳﺎﺳﯿﺎ ً ﻣﻦ ﻧﻈﺎم اﺗﺼﺎﻻت‪ ،‬أو ﻧﻈﺎم ﺑﻨﻜﻲ‪ ،‬أو أﻟﻌﺎب‬
‫ﺣﺎﺳﻮب‪ ،‬أو ﺣﺘﻰ أﯾﺔ ﺟﮭﺎز إﻟﻜﺘﺮوﻧﻲ‪ .‬إن ﻧﻈﺎم إدارة ﻗﻮاﻋﺪ اﻟﺒﯿﺎﻧﺎت )‪ ،database management system (DBMS‬ھﻮ ﻋﺒﺎرة‬
‫ﻋﻦ ﺗﻄﺒﯿﻖ ﺑﺮﻣﺠﻲ ‪ software‬ﺣﺎﺳﻮﺑﻲ‪ ،‬واﻟﺬي ﯾﺘﻌﺎﻣﻞ ﻣﻊ ﻣﺴﺘﺨﺪم أو ﺗﻄﺒﯿﻘﺎت أو ﻧﻔﺲ ﻗﺎﻋﺪة اﻟﺒﯿﺎﻧﺎت ﻣﻦ أﺟﻞ ﺟﻠﺐ وﺗﺤﻠﯿﻞ‬
‫اﻟﺒﯿﺎﻧﺎت‪ .‬ﯾﺘﻢ ﺗﺼﻤﯿﻢ ﻧﻈﺎم ﻗﻮاﻋﺪ ﺑﯿﺎﻧﺎت ﻋﺎم اﻟﻤﮭﻤﺎت )‪ ،(general-purpose DBMS‬ﻣﻦ أﺟﻞ اﻟﻘﯿﺎم ﺑﻤﮭﻤﺎت ﻋﺎﻣﺔ ﻣﺜﻞ ﺗﻌﺮﯾﻒ‬
‫ﻗﺎﻋﺪة ﺑﯿﺎﻧﺎت‪ ،‬إﻧﺸﺎء ﻗﺎﻋﺪة ﺑﯿﺎﻧﺎت‪ ،‬اﻻﺳﺘﻌﻼم ﻋﻦ ﻣﺤﺘﻮﯾﺎت ﻗﺎﻋﺪة ﺑﯿﺎﻧﺎت‪ ،‬ﺗﺤﺪﯾﺚ ﻗﺎﻋﺪة ﺑﯿﺎﻧﺎت‪ ،‬ﺑﺎﻹﺿﺎﻓﺔ إﻟﻰ إدارة ﻗﻮاﻋﺪ اﻟﺒﯿﺎﻧﺎت‪.‬‬
‫ﺑﻌﺾ اﻷﻣﺜﻠﺔ ﻋﻠﻰ ﻧﻈﻢ ﻗﻮاﻋﺪ اﻟﺒﯿﺎﻧﺎت ‪MySQL, PostgreSQL, Oracle, MS SQL Server, Sybase, SAP HANA,‬‬
‫‪.IBM DB2‬‬
‫ﻟﯿﺲ ﺑﺎﻟﻀﺮورة أن ﺗﻌﻤﻞ ﻗﺎﻋﺪة ﺑﯿﺎﻧﺎت ﻣﻌﯿﻨﺔ ﻋﻠﻰ ﺟﻤﯿﻊ ﻧﻈﻢ إدارة ﻗﻮاﻋﺪ اﻟﺒﯿﺎﻧﺎت ‪ ،DBMS‬وﻟﻜﻦ ﯾﻤﻜﻦ اﺳﺘﺨﺪام ﻣﻌﺎﯾﯿﺮ ﻋﺎﻟﻤﯿﺔ‬
‫ﻟﻠﺘﻮاﺻﻞ ﻣﻊ ﺗﻠﻚ اﻟﻨﻈﻢ وﻓﯿﻤﺎ ﺑﯿﻨﮭﺎ أﯾﻀﺎ ﻣﺜﻞ ﻣﻌﺎﯾﯿﺮ ‪ .SQL, JDBC, ODBC‬ﺑﺎﻟﺘﺎﻟﻲ ﻧﺴﻤﺢ ﻷﯾﺔ ﺗﻄﺒﯿﻖ أن ﯾﺘﻮاﺻﻞ ﻣﻊ ﻗﺎﻋﺪة‬
‫اﻟﺒﯿﺎﻧﺎت ﻣﻦ ﻏﯿﺮ ﻣﻌﺮﻓﺔ اﻟﻜﺜﯿﺮ ﻋﻦ ﺗﺼﻤﯿﻤﮭﺎ أو ﻧﻮﻋﮭﺎ‪ .‬ﻣﻦ أﻛﺜﺮ أﻧﻮاع اﻟﺒﯿﺎﻧﺎت ﺷﮭﺮة ﻗﻮاﻋﺪ اﻟﺒﯿﺎﻧﺎت اﻟﻌﻼﺋﻘﯿﺔ ‪Relational‬‬
‫‪ DBMS‬أو )‪ ،(RDBMS‬واﻟﺬي ﯾﻌﺘﺒﺮ ‪ MySQL‬أﺷﮭﺮھﺎ ﺧﺼﻮﺻﺎ ﻓﻲ ﺗﻄﺒﯿﻘﺎت اﻟﻮﯾﺐ واﻻﻧﺘﺮﻧﺖ‪.‬‬
‫‪ .1‬أن ﺗﺘﻌﺮف ﻋﻠﻰ ﺑﯿﺌﺔ ﻗﻮاﻋﺪ ﺑﯿﺎﻧﺎت ‪ ،MySQL‬وطﺮﯾﻘﺔ ﺗﺸﻐﯿﻠﮭﺎ واﻟﻌﻤﻞ ﻋﻠﯿﮭﺎ‪.‬‬
‫‪ .2‬أن ﺗﻌﻤﻞ ﻋﻠﻰ إﻧﺸﺎء ﻗﺎﻋﺪة ﺑﯿﺎﻧﺎت ﺧﺎﺻﺔ ﺑﺎﻟﺰﺑﺎﺋﻦ ﻓﻲ ﺑﯿﺌﺔ ‪ ،MySQL‬وﺗﻨﺸﺊ ﺟﺪول ﯾﺤﻮي ﺑﯿﺎﻧﺎﺗﮭﻢ اﻟﺸﺨﺼﯿﺔ وآﺧﺮ ﯾﺤﻮي‬
‫طﻠﺒﯿﺎﺗﮭﻢ‪.‬‬
‫‪ .3‬أن ﺗﺘﻌﺮف ﻋﻠﻰ طﺮﯾﻘﺔ اﺳﺘﻌﺮاض ﻛﺎﻓﺔ ﻣﺤﺘﻮﯾﺎت اﻟﺠﺪول أو أن ﺗﺨﺘﺎر ﺟﺰء ﻣﻨﮭﺎ‪.‬‬
‫‪ .4‬أن ﺗﺘﻌﺮف ﻋﻠﻰ طﺮﯾﻘﺔ اﻟﺮﺑﻂ ﺑﯿﻦ اﻟﺠﺪوﻟﯿﻦ ﻓﻲ ﻧﻔﺲ ﻗﺎﻋﺪة اﻟﺒﯿﺎﻧﺎت‪ ،‬ﺑﺤﯿﺚ ﺗﺮﺑﻂ ﻛﻞ زﺑﻮن ﻓﻲ اﻟﺠﺪول اﻷول ﺑﻄﻠﺒﯿﺎﺗﮫ ﻓﻲ‬
‫اﻟﺠﺪول اﻟﺜﺎﻧﻲ‪.‬‬
‫ﺧﻄﻮات ﻋﻤﻞ اﻟﺠﺰء اﻷول‬
‫ﺳﯿﺘﻢ ﻓﻲ ھﺬا اﻟﺠﺰء اﻟﺘﻌﺮف ﻋﻠﻰ طﺮﯾﻘﺔ اﻟﺪﺧﻮل إﻟﻰ ﻗﺎﻋﺪة اﻟﺒﯿﺎﻧﺎت‪ .‬ﺷ ّﻐﻞ‪ ،‬ﻋﺰﯾﺰي اﻟﺪارس‪ ،‬ﺷﺎﺷﺔ ‪ ،DOS‬ﺛﻢ أدﺧﻞ إﻟﻰ ﻣﺠﻠﺪ ‪bin‬‬
‫اﻟﻤﻮﺟﻮد ﻓﻲ ﻣﺠﻠﺪ ‪ ،mysql‬واﻟﻤﻮﺟﻮد ﻓﻲ ﻣﺠﻠﺪ ‪ xampp‬ﻋﻦ طﺮﯾﻖ أﻣﺮ ‪ DOS‬وھﻮ ‪ .CD‬ﻣﻦ ھﻨﺎ ﯾﻤﻜﻦ إطﻼق ﻋﻤﻞ ‪MySQL‬‬
‫ﻣﻦ ﺧﻼل اﻷﻣﺮ ‪ ،mysql –u root –p‬واﻟﺬي ﯾﺤﺪد اﺳﻢ اﻟﻤﺴﺘﺨﺪم "‪ ،"root‬وﻛﻠﻤﺔ اﻟﻤﺮور‪ .‬ﻋﻨﺪﻣﺎ ﯾﻄﻠﺐ ﻛﻠﻤﺔ اﻟﻤﺮور‪ ،‬ﻻ ﻧﻜﺘﺐ‬
‫ﺷﻲء ﻟﻌﺪم وﺟﻮد ﻛﻠﻤﺔ ﻣﺮور أﺻﻼ ﻋﻠﻰ اﻟﻤﺴﺘﺨﺪم ‪ .root‬اﻵن ﯾﻤﻜﻨﻚ اﻟﺒﺪء ﺑﺈﻋﻄﺎء أو ﻛﺘﺎﺑﺔ أواﻣﺮ ‪ sql‬ﻓﻲ ﻧﺎﻓﺬة ‪.mysql‬‬
‫ﻧﺮﯾﺪ إﻧﺸﺎء ﻗﺎﻋﺪة ﺑﯿﺎﻧﺎت ﻟﻠﺰﺑﺎﺋﻦ ﺑﺄﺳﻢ ‪ .customers‬ﯾﻢ ذﻟﻚ ﻣﻦ ﺧﻼل اﻷﻣﺮ ;‪ .CREATE DATABASE customers‬وﺗﻜﻮن‬
‫اﻟﻨﺘﯿﺠﺔ إﯾﺠﺎﺑﺎ ً إن ﺗﻢ إﻧﺸﺎء ﻗﺎﻋﺪة اﻟﺒﯿﺎﻧﺎت‪ .‬ﻋﻨﺪھﺎ ﯾﻤﻜﻦ اﻟﺒﺪء ﺑﺎﺳﺘﺨﺪاﻣﮭﺎ ﻣﻦ ﺧﻼل اﻷﻣﺮ ;‪ .USE customers‬ﻓﯿﻤﻜﻦ إﻧﺸﺎء ﺟﺪول‬
‫ﺑﺄﺳﻢ ‪ ،Persons‬وﯾﺤﺘﻮي ﻋﻠﻰ ﺧﻤﺴﺔ أﻋﻤﺪة ‪ columns‬ﻛﻤﺎ ﯾﻠﻲ‪:‬‬
‫اﻟﻌﻤﻮد اﻷول ﻣﻌ ﱢﺮف ‪ identifier‬ﻟﻠﺸﺨﺺ ‪ person‬ﺑﻌﻨﻮان ‪ ،p_id‬ﻣﻦ ﻧﻮع ﻋﺪد ﺻﺤﯿﺢ ‪ ،int‬وﯾﺠﺐ أن ﻻ ﺗﻜﻮن ﻗﯿﻤﺘﮫ‬ ‫‪.1‬‬
‫ﻓﺮاغ‪ ،‬وھﻮ ﻣﻔﺘﺎح أﺳﺎﺳﻲ ‪.PRIMARY KEY‬‬
‫اﻟﻌﻤﻮد اﻟﺜﺎﻧﻲ أﺳﻢ اﻟﻌﺎﺋﻠﺔ أو اﻷﺳﻢ اﻷﺧﯿﺮ ﻟﻠﺸﺨﺺ ﺑﻌﻨﻮان ‪ ،LastName‬ﻣﻦ ﻧﻮع ﺣﺮوف ﻣﺘﻐﯿﺮة ‪ ،varchar‬وﯾﺠﺐ أن ﻻ‬ ‫‪.2‬‬
‫ﺗﻜﻮن ﻗﯿﻤﺘﮫ ﻓﺮاغ‪ ،‬وﺑﺤ ّﺪ أﻗﺼﻰ ‪ 255‬ﺣﺮف‪.‬‬
‫اﻟﻌﻤﻮد اﻟﺜﺎﻟﺚ اﻷﺳﻢ اﻷول ﻟﻠﺸﺨﺺ ﺑﻌﻨﻮان ‪ ،FirstName‬ﻣﻦ ﻧﻮع ﺣﺮوف ﻣﺘﻐﯿﺮة ‪ ،varchar‬وﺑﺤ ّﺪ أﻗﺼﻰ ‪ 255‬ﺣﺮف‪.‬‬ ‫‪.3‬‬
‫اﻟﻌﻤﻮد اﻟﺮاﺑﻊ ﻟﻠﻌﻨﻮان اﻟﺒﺮﯾﺪي ‪ ،Address‬ﻣﻦ ﻧﻮع ﺣﺮوف ﻣﺘﻐﯿﺮة ‪ ،varchar‬وﺑﺤ ّﺪ أﻗﺼﻰ ‪ 255‬ﺣﺮف‪.‬‬ ‫‪.4‬‬
‫اﻟﻌﻤﻮد اﻟﺨﺎﻣﺲ ﻟﻠﻤﺪﯾﻨﺔ ‪ ،City‬ﻣﻦ ﻧﻮع ﺣﺮوف ﻣﺘﻐﯿﺮة ‪ ،varchar‬وﺑﺤ ّﺪ أﻗﺼﻰ ‪ 255‬ﺣﺮف‪.‬‬ ‫‪.5‬‬
‫ّ‬
‫ﺻﻒ‪ .‬ﻛﻞ ﺻﻒ ﯾﺤﻤﻞ ﻗﯿﻢ اﻷﻋﻤﺪة اﻟﺴﺎﻟﻔﺔ اﻟﺬﻛﺮ اﻟﺘﻲ ﺗﻢ‬ ‫ّ‬
‫ﺻﻒ ﯾﻠﯿﮫ‬ ‫اﻵن ﯾﻤﻜﻦ إدﺧﺎل اﻟﻘﯿﻢ إﻟﻰ اﻟﺠﺪول ﺑﺎﺳﺘﺨﺪام اﻟﺼﻔﻮف ‪،rows‬‬
‫إﻧﺸﺎؤھﺎ ﻓﻲ اﻟﺨﻄﻮة اﻟﺴﺎﺑﻘﺔ‪ .‬ھﺬا ﯾﺘﻢ ﻣﻦ ﺧﻼل اﻷﻣﺮ ‪ ،INSERT INTO Persons‬واﻟﺬي ﯾﻌﻤﻞ ﻋﻠﻰ إدﺧﺎل ﻗﯿﻢ ﻟﻸﻋﻤﺪة ﺑﻨﻔﺲ‬
‫ﺗﺮﺗﯿﺐ اﻷﻋﻤﺪة‪ ،‬ﺣﯿﺚ ﺗﺄﺧﺬ اﻟﻘﯿﻢ ‪ VALUES‬ﺑﺎﻟﺸﺮوط اﻟﻤﺤﺪدة ﻣﺴﺒﻘﺎ ﻋﻨﺪ إﻧﺸﺎء اﻟﺠﺪول‪ .‬ﯾﺘﻢ ﺗﻜﺮار ﻧﻔﺲ اﻷﻣﺮ ﻟﻜﻞ زﺑﻮن‪ ،‬وﻟﻜﻦ‬
‫ﺑﺎﺧﺘﻼف اﻟﻘﯿﻢ طﺒﻌﺎ‪.‬‬
‫ﻣﻦ أﺟﻞ اﺳﺘﻌﺮاض ﻣﺤﺘﻮﯾﺎت اﻟﺠﺪول‪ ،‬ﻧﺴﺘﺨﺪم أﻣﺮ ‪ SQL‬اﻟﺘﺎﻟﻲ‪ ،SELECT * FROM Persons; :‬ﻓﻌﻼﻣﺔ اﻟﻨﺠﻤﺔ ﺗﺸﯿﺮ إﻟﻰ‬
‫ﺟﻤﯿﻊ ﻣﺤﺘﻮﯾﺎت اﻟﺠﺪول‪.‬‬
‫ﻻﺳﺘﻌﺮاض ﺟﺰء ﻣﻦ ﻣﺤﺘﻮﯾﺎت اﻟﺠﺪول وﻟﯿﺲ ﺟﻤﯿﻊ اﻟﻤﺤﺘﻮﯾﺎت‪ ،‬ﻧﺨﺘﺎر ﻣﺤﺘﻮﯾﺎت اﻷﻋﻤﺪة اﻟﺘﻲ ﻧﺮﯾﺪ ﻋﺮﺿﮭﺎ ﻟﻜﻞ زﺑﻮن‪ .‬ﻓﻤﺜﻼ إن‬
‫أردﻧﺎ أن ﻧﻌﺮف ﻣﻌﺮف اﻟﺰﺑﻮن ‪ ،p_id‬واﺳﻤﮫ اﻷﺧﯿﺮ ﻓﻘﻂ‪ ،‬ﻧﺴﺘﺨﺪم اﻷﻣﺮ ;‪.SELECT p_id, LastName FROM Persons‬‬
‫ﻛﻤﺎ ﯾﻤﻜﻨﻨﺎ أن ﺿﻊ ﺷﺮط ﻋﻠﻰ اﻻﺧﺘﯿﺎرات‪ ،‬ﻓﻤﺜﻼ ﻻﺳﺘﻌﺮاض ﻛﻞ اﻟﺒﯿﺎﻧﺎت اﻟﺘﻲ ﺗﺘﻌﻠﻖ ﺑﺸﺨﺺ ﻣﻌﯿﻦ‪ ،‬ﯾﻤﻜﻦ اﺳﺘﺨﺪام اﻷﻣﺮ اﻟﺘﺎﻟﻲ‪:‬‬
‫ﺧﻄﻮات ﻋﻤﻞ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫ﻓﻲ ھﺬا اﻟﺠﺰء‪ ،‬ﯾﺘﻄﻠﺐ ﻣﻨﻚ ﻋﺰﯾﺰي اﻟﺪارس إﻧﺸﺎء ﺟﺪول آﺧﺮ ﻟﻄﻠﺒﺎت اﻟﺰﺑﺎﺋﻦ ﺑﺄﺳﻢ ‪ .Orders‬ﺳﯿﺘﻢ رﺑﻂ ھﺬا اﻟﺠﺪول ﺑﺎﻟﺠﺪول اﻷول‪،‬‬
‫واﻟﺬي ﯾﺘﻌﻠﻖ ﺑﺎﻟﺒﯿﺎﻧﺎت اﻟﺸﺨﺼﯿﺔ ﻟﻠﺰﺑﻮن‪ ،‬ﻣﻦ ﺧﻼل اﻟﻤﻔﺘﺎح اﻷﺟﻨﺒﻲ ‪ .FOREIGN KEY‬ﺳﯿﺤﺘﻮي اﻟﺠﺪول اﻟﺠﺪﯾﺪ ﻋﻠﻰ ﻣﻌﺮف‬
‫طﻠﺒﯿﺔ ﺑﺄﺳﻢ ‪ ،o_id‬ورﻗﻢ طﻠﺒﯿﺔ ‪ ،OrderNo‬ﺑﺎﻹﺿﺎﻓﺔ طﺒﻌﺎ إﻟﻰ رﻗﻢ اﻟﺰﺑﻮن ﺻﺎﺣﺐ اﻟﻄﻠﺒﯿﺔ‪ .‬ھﺬا اﻟﺤﻘﻞ ﺳﯿﺴﺘﺨﺪم ﻛﻮﺳﯿﻂ ﻟﻠﺮﺑﻂ ﻣﺎ‬
‫ﺑﯿﻦ اﻟﺠﺪوﻟﯿﻦ ﺑﺎﺳﺘﺨﺪام أﻣﺮ ‪ SQL‬اﻟﺘﺎﻟﻲ‪ .FOREIGN KEY (p_id) REFERENCES Persons (p_id) :‬ﻛﻤﺎ ﺗﺮى‪،‬‬
‫ﻋﺰﯾﺰي اﻟﺪارس‪ ،‬ﻓﺈن اﻟﻤﺮﺟﻊ ‪ reference‬ھﻮ ﻣﻌ ﱢﺮف اﻟﺰﺑﻮن ﻓﻲ ﺟﺪول ‪.Persons‬‬
‫ﺑﻨﻔﺲ اﻟﻄﺮﯾﻘﺔ اﻟﺴﺎﺑﻘﺔ‪ ،‬أدﺧﻞ اﻟﻘﯿﻢ اﻟﺘﺎﻟﯿﺔ إﻟﻰ اﻟﺠﺪول اﻟﺠﺪﯾﺪ‪.‬‬
‫ﻟﻠﺘﺄﻛﺪ ﻣﻦ أن اﻟﺒﯿﺎﻧﺎت اﻟﻤﺪﺧﻠﺔ ﺻﺤﯿﺤﺔ‪ ،‬اﺳﺘﻌﺮض ﻛﺎﻓﺔ ﻣﺤﺘﻮﯾﺎت اﻟﺠﺪول‪:‬‬
‫ﯾﻤﻜﻨﻚ أﯾﻀﺎ اﺳﺘﻌﺮاض ﺑﻌﺾ ﻣﺤﺘﻮﯾﺎت اﻟﺠﺪول‪ ،‬ﻣﺜﻼ رﻗﻢ اﻟﻄﻠﺒﺔ ورﻗﻢ اﻟﺰﺑﻮن ﻓﻘﻂ‪ ،‬ﻟﺠﻤﯿﻊ اﻟﺰﺑﺎﺋﻦ‪ ،‬ﻛﻤﺎ ﯾﻠﻲ‪:‬‬
‫أو أن ﺗﺴﺘﻌﺮض ﺟﻤﯿﻊ اﻟﻄﻠﺒﺎت اﻟﺘﻲ ﺗﺘﻌﻠﻖ ﺑﺰﺑﻮن ﻣﻌﯿﻦ ﻣﻦ ﺧﻼل رﻗﻢ اﻟﺘﻌﺮﯾﻒ )اﻟﻤﻌﺮﱢ ف(‪:‬‬
‫ﻛﻤﺎ ﯾﻤﻜﻨﻚ اﺳﺘﻌﺮاض ﺑﻌﺾ ﻣﺤﺘﻮﯾﺎت اﻟﺠﺪوﻟﯿﻦ ﻓﻲ ﻧﻔﺲ اﻟﻮﻗﺖ‪ .‬ﺗﺬﻛﺮ ﻋﺰﯾﺰي اﻟﺪارس‪ ،‬أﻧﻨﺎ ﻗﻤﻨﺎ ﺑﺮﺑﻂ اﻟﺠﺪوﻟﯿﻦ ﻣﻦ ﺧﻼل اﻟﻤﻔﺘﺎح‬
‫اﻷﺟﻨﺒﻲ ‪ .FOREIGN KEY‬ﻓﯿﻤﻜﻦ أن ﻧﺴﺘﻌﺮض أﺳﻢ اﻟﻌﺎﺋﻠﺔ ﻟﺰﺑﻮن ﻣﻦ ﺟﺪول ‪ ،Persons‬ورﻗﻢ اﻟﻄﻠﺒﯿﺔ ﻣﻦ اﻟﺠﺪول ‪،Orders‬‬
‫ﺑﺸﺮط أن ﯾﺘﺴﺎوى اﻟﺮﻗﻢ اﻟﻤﻌﺮف )‪ (p_id‬ﻓﻲ ﻛﻼ اﻟﺠﺪوﻟﯿﻦ‪ .‬ﻻﺳﺘﻌﺮاض طﻠﺒﯿﺎت زﺑﻮن ﻣﻌﯿﻦ ﻧﺸﺘﺮط أن ﯾﻜﻮن اﻟﺮﻗﻢ اﻟﻤﻌﺮف ‪،p_id‬‬
‫ﺻﻔﺮ‪.‬‬
‫ﺑﻌﺪ اﻻﻧﺘﮭﺎء ﻣﻦ اﻟﻌﻤﻞ ﻋﻠﻰ ‪ ،MySQL‬ﯾﻤﻜﻨﻚ اﻹﻧﮭﺎء ﺑﺎﺳﺘﺨﺪام اﻷﻣﺮ ‪ ،quit‬ﻛﻤﺎ ﯾﻠﻲ‪:‬‬
‫اﻟﻨﺸﺎط اﻟﺼﻔﻲ اﻟﺨﺎﻣﺲ‬
‫رﺑﻂ ﻗﻮاﻋﺪ اﻟﺒﯿﺎﻧﺎت ﺑﻠﻐﺔ ﺑﺮﻣﺠﺔ اﻟﻮﯾﺐ‬

‫‪PHP and MySQL‬‬
‫ﻋﺰﯾﺰي اﻟﺪارس‪ ،‬ﻻ ﯾﻜﺎد ﯾﺨﻠﻮ ﻣﻮﻗﻊ وﯾﺐ ﻣﺨﺘﺺ ﺑﺎﻟﺘﺴﻮق ‪ online shopping‬ﻣﻦ ﻗﻮاﻋﺪ ﺑﯿﺎﻧﺎت‪ ،‬وﻛﺜﯿﺮ ﻣﻦ ﻣﻮاﻗﻊ اﻟﺸﺮﻛﺎت‬
‫اﻟﻜﺒﺮى‪ ،‬ﺗﺴﺘﺨﺪم ﻗﻮاﻋﺪ اﻟﺒﯿﺎﻧﺎت ﺑﺸﻜﻞ ﻣﻠﻔﺖ‪ .‬ﻧﺎھﯿﻚ ﻋﻦ ﻣﻮاﻗﻊ اﻟﺘﻮاﺻﻞ اﻻﺟﺘﻤﺎﻋﻲ اﻟﺘﻲ ﺗﻌﺘﻤﺪ ﺑﺸﻜﻞ ﻛﻠﻲ ﺗﻘﺮﯾﺒﺎ ﻋﻠﻰ ﻗﻮاﻋﺪ اﻟﺒﯿﺎﻧﺎت‪.‬‬
‫وﻟﻜﻦ ﺳ ّﺮ ﻗﻮة ﻗﻮاﻋﺪ اﻟﺒﯿﺎﻧﺎت ﯾﻜﻤﻦ ﻓﻲ إﻧﺸﺎء واﺟﮭﺔ رﺳﻮﻣﺎت ﺗﺨﺎطﺒﯿﺔ ‪ GUI‬ﻣﻊ اﻟﻤﺴﺘﺨﺪم ﻟﯿﺴﮭﻞ اﻟﺘﻌﺎﻣﻞ ﻣﺎ ﺑﯿﻦ اﻟﻤﺴﺘﺨﺪم وﻗﻮاﻋﺪ‬
‫اﻟﺒﯿﺎﻧﺎت‪ .‬وھﻨﺎ ﯾﺄﺗﻲ دور ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ ﻓﻲ ﺗﻘﺪﯾﻢ واﺟﮭﺔ اﻟﺘﺨﺎطﺐ ‪ GUI‬ﺗﺴﮭﯿﻞ اﻟﺘﻌﺎﻣﻞ ﻣﻊ ﻣﺤﺮك ﻗﻮاﻋﺪ اﻟﺒﯿﺎﻧﺎت ‪Database‬‬
‫‪ .Engine‬ﻓﻲ ھﺬه اﻟﺘﺠﺮﺑﺔ‪ ،‬ﺳﺘﻌﻤﻞ ﺑﻤﺴﺎﻋﺪة ﻣﺸﺮﻓﻚ اﻷﻛﺎدﯾﻤﻲ وﻓﻨﻲ اﻟﻤﺨﺘﺒﺮ‪ ،‬ﻋﻠﻰ إﻧﺸﺎء واﺟﮭﺖ ﺗﺨﺎطﺐ ‪ GUI‬ﻣﻊ اﻟﻤﺴﺘﺨﺪم ﻓﻲ‬
‫اﻟﻤﺘﺼﻔﺢ ‪ ،Browser‬ﻣﻦ ﺧﻼل ﻟﻐﺔ ﺑﺮﻣﺠﺔ اﻟﻮﯾﺐ ‪ ،PHP‬ﺑﺤﯿﺚ ﯾﻜﻮن اﻟﻤﺴﺘﺨﺪم ﻗﺎدرا ﻋﻠﻰ إﺿﺎﻓﺔ ﺑﯿﺎﻧﺎت إﻟﻰ ﻗﺎﻋﺪة اﻟﺒﯿﺎﻧﺎت أو‬
‫ﺣﺬف ﺑﯿﺎﻧﺎت ﻣﻦ ﺗﻠﻚ اﻟﻘﺎﻋﺪة‪.‬‬
‫‪ .1‬أن ﺗﺘﻌﺮف ﻋﻠﻰ طﺮﯾﻘﺔ رﺑﻂ ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ ‪ PHP‬ﻣﻊ ﻗﻮاﻋﺪ اﻟﺒﯿﺎﻧﺎت ‪.MySQL‬‬
‫‪ .2‬أن ﺗﺘﻌﺮف ﻋﻠﻰ اﻟﺪوال اﻟﺠﺎھﺰة ﻓﻲ ﻟﻐﺔ ‪ ،PHP‬واﻟﺘﻲ ﺗﺨﺘﺺ ﺑﻤﻌﺎﻟﺠﺔ ﻗﻮاﻋﺪ ﺑﯿﺎﻧﺎت ‪.MySQL‬‬
‫‪ .3‬أن ﺗﺘﻌﺮف ﻋﻠﻰ طﺮﯾﻘﺔﺟﻠﺐ ‪ fetch‬ﺑﯿﺎﻧﺎت ﻣﻌﯿﻨﺔ ﺑﻮاﺳﻄﺔ ﻟﻐﺔ ‪ PHP‬ﻣﻦ ﻗﺎﻋﺪة ﺑﯿﺎﻧﺎت ﺗﻢ إﻧﺸﺎﺋﮭﺎ ﻣﺴﺒﻘﺎ ﻓﻲ ‪.MySQL‬‬
‫‪ .4‬أن ﺗﻌﻤﻞ ﻋﻠﻰ إدﺧﺎل ﺑﯿﺎﻧﺎت إﻟﻰ ﻗﺎﻋﺪة ﺑﯿﺎﻧﺎت ﺗﻢ إﻧﺸﺎﺋﮭﺎ ﻣﺴﺒﻘﺎ ﻣﻦ ﺧﻼل ﺻﻔﺤﺔ ‪.PHP‬‬

‫ھﺬا اﻟﺠﺰء ﯾﺤﻘﻖ اﻟﮭﺪﻓﯿﻦ اﻷول واﻟﺜﺎﻧﻲ‪ ،‬وھﻤﺎ طﺮﯾﻘﺔ رﺑﻂ ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ ‪ PHP‬ﻣﻊ ﻗﻮاﻋﺪ ﺑﯿﺎﻧﺎت ‪ ،MySQL‬واﻟﺪوال اﻟﺘﻲ ﺗﻌﺎﻟﺞ ھﺬا‬
‫اﻷﻣﺮ ﻓﻲ ﻟﻐﺔ ‪ .PHP‬ﻟﻨﺘﺬﻛﺮ أن ﻣﻨﻔﺬ ‪ port‬اﻟﺨﺎص ﺑﻨﻈﺎم إدارة ﻗﻮاﻋﺪ ﺑﯿﺎﻧﺎت ‪ ،MySQL‬ھﻮ ‪ 3306‬وﺑﺎﻟﺘﺎﻟﻲ‪ ،‬ﻓﺈﻧﻨﺎ ﻧﻌ ّﺮف اﻟﺠﮭﺎز‬
‫اﻟﻤﻀﯿﻒ ﻓﻲ ﻣﺘﻐﯿﺮ ‪ dbhost‬ﺑﺤﯿﺚ ﯾﺤﻤﻞ اﻟﻘﯿﻤﺔ "‪ ."localhost:3306‬أﻣﻞ أﺳﻢ اﻟﻤﺴﺘﺨﺪم ﻓﮭﻮ ‪ ،root‬وﺑﺪون ﻛﻠﻤﺔ اﻟﻤﺮور ﻷﻧﻨﺎ ﻟﻢ‬
‫ﻧﺤﺪدھﺎ ﻣﺴﺒﻘﺎ‪ .‬اﻟﺒﺮﻧﺎﻣﺞ اﻟﺘﺎﻟﻲ ﯾﺮﺑﻂ ﻣﻊ ﻗﺎﻋﺪة اﻟﺒﯿﺎﻧﺎت ﻣﻦ ﻏﯿﺮ أن ﯾﻨﻔﺬ أﯾﺔ أﻣﺮ ﻣﻦ أواﻣﺮ ‪ .MySQL‬ﯾﺘﻢ اﻟﺮﺑﻂ ﻣﻦ ﺧﻼل اﺳﺘﺪﻋﺎء‬
‫اﻟﺪاﻟﺔ اﻟﺠﺎھﺰة ‪ ،mysql_connect‬واﻟﺘﻲ ﺗﺄﺧﺬ ﺛﻼﺛﺔ ﻣﺘﻐﯿﺮات‪ :‬أﺳﻢ اﻟﻤﻀﯿﻒ واﻟﻤﻨﻔﺬ ﻛﻤﺘﻐﯿﺮ أول‪ ،‬واﻟﻤﺘﻐﯿﺮ اﻟﺜﺎﻧﻲ اﻟﺬي ﯾﺤﻤﻞ أﺳﻢ‬
‫اﻟﻤﺴﺘﺨﺪم‪ ،‬واﻟﻤﺘﻐﯿﺮ اﻟﺜﺎﻟﺚ اﻟﺬي ﯾﺤﻤﻞ ﻛﻠﻤﺔ اﻟﻤﺮور‪ .‬ﻓﻲ ﺣﺎل ﻧﺠﺢ اﻟﺮﺑﻂ ﺗﻌﯿﺪ ھﺬه اﻟﺪاﻟﺔ ‪ ،true‬وإﻻ ﻓﺈﻧﮭﺎ ﺗﻌﯿﺪ ‪ .false‬ﻧﻔﺤﺺ إن ﻟﻢ‬
‫ﯾﻨﺠﺢ اﻻﺗﺼﺎل‪ ،‬ﻧﻮﻗﻒ اﻟﻌﻤﻠﯿﺔ ﻋﻦ طﺮﯾﻖ اﻟﺪاﻟﺔ اﻟﺠﺎھﺰة ‪ ،die‬ﺣﯿﺚ ﻧﺴﺘﺪﻋﻲ اﻟﺪاﻟﺔ اﻟﺘﻲ ﺗﺤﻤﻞ اﻟﺨﻄﺄ وھﻲ ‪ .mysql_error‬ﻋﻨﺪ‬
‫اﻻﻧﺘﮭﺎء ﻣﻦ ﻓﺤﺺ اﻟﺮﺑﻂ‪ ،‬ﻧﻐﻠﻘﮫ ﺑﺎﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ )(‪ ،mysql_close‬وﻧﻤﺮر ﻟﮭﺎ أﺳﻢ اﻟﺮاﺑﻂ‪.‬‬
‫اﻟﻤﺜﺎل اﻷول ‪see1.php‬‬

‫‪<?php‬‬
‫‪$dbhost = 'localhost:3306'; # check with the XAMPP control panel for the working port‬‬
‫;'‪$dbuser = 'root‬‬
‫;'' = ‪$dbpass‬‬
‫;)‪$conn = mysql_connect($dbhost, $dbuser, $dbpass‬‬
‫) ‪if(! $conn‬‬
‫{‬
‫;) )(‪die( 'Could not connect: ' . mysql_error‬‬
‫}‬
‫;'>‪echo '<br>Connected Successfully!<br‬‬
‫;'>‪echo '<br> - - - - - <br‬‬
‫;)‪mysql_close($conn‬‬
‫;' >‪echo '<br><b>Connection Closed!</b><br‬‬
‫>?‬
‫ﻣﻼﺣﻈﺔ‪ :‬ﻋﺰﯾﺰي اﻟﺪارس‪ ،‬ﯾﺠﺐ أن ﯾﻜﻮن ﻛﻞ ﻣﻦ ‪ MySQL‬و ‪ Apache‬ﻓﻲ ﺣﺎﻟﺔ اﻟﺘﺸﻐﯿﻞ ﻣﻦ أﺟﻞ ﺗﻨﻔﯿﺬ أﻣﺜﻠﺔ ھﺬه اﻟﺘﺠﺮﺑﺔ‪.‬‬

‫ھﺬا اﻟﺠﺰء ﯾﻮﺿﺢ ﺟﻠﺐ ‪ fetch‬ﺑﯿﺎﻧﺎت ﻣﻌﯿﻨﺔ ﻣﻦ ﻗﺎﻋﺪة اﻟﺒﯿﺎﻧﺎت اﻟﺘﻲ ﺗﻢ إﻧﺸﺎﺋﮭﺎ ﻣﺴﺒﻘﺎ وھﻲ ‪ ،customers‬وﺑﺎﻟﺘﺎﻟﻲ ﯾﺤﻘﻖ اﻟﮭﺪف‬
‫اﻟﺜﺎﻧﻲ‪ .‬ﻧﻔﺲ اﻟﻄﺮﯾﻘﺔ اﻟﺘﻲ اﺳﺘﺨﺪﻣﺘﮭﺎ ﻟﻠﺮﺑﻂ ﻣﻊ ﻗﻮاﻋﺪ اﻟﺒﯿﺎﻧﺎت ﻓﻲ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ‪ ،‬ﺳﻮف ﺗﺴﺘﺨﺪﻣﮭﺎ ﻓﻲ ھﺬا اﻟﻤﺜﺎل أﯾﻀﺎ‪ .‬وﻟﻜﻦ اﻟﺠﺪﯾﺪ‬
‫ﻓﻲ ھﺬا اﻟﻤﺜﺎل‪ ،‬ھﻮ اﻧﻚ ﺳﺘﻌﻤﻞ ﻋﻠﻰ ﺗﻨﻔﯿﺬ ﺟﻤﻞ ‪ SQL‬ﻟﺠﻠﺐ ‪ fetch‬ﺑﯿﺎﻧﺎت اﻟﺰﺑﺎﺋﻦ ﻣﻦ ﻗﺎﻋﺪة اﻟﺒﯿﺎﻧﺎت ‪ .customers‬دوال ‪PHP‬‬
‫اﻟﺠﺎھﺰة اﻟﺘﻲ ﻧﺤﺘﺎﺟﮭﺎ ﻟﮭﺬا اﻟﮭﺪف ھﻲ )(‪ mysql_select_db‬واﻟﺘﻲ ﺗﻨﻔﺬ أﻣﺮ ‪ sql‬اﻟﺨﺎص ﺑﺎﺧﺘﯿﺎر ﻗﺎﻋﺪة اﻟﺒﯿﺎﻧﺎت ﻣﻦ أﺟﻞ اﻟﻌﻤﻞ‬
‫ﻋﻠﯿﮭﺎ‪ ،‬واﻟﺪاﻟﺔ )(‪ mysql_query‬واﻟﺘﻲ ﺗﻨﻔﺬ أواﻣﺮ ‪ sql‬اﻟﺨﺎﺻﺔ ﺑﺎﻻﺳﺘﻌﻼم‪ ،‬واﺧﯿﺮا اﻟﺪاﻟﺔ )(‪ mysql_fetch_array‬واﻟﺘﻲ ﺗﻌﻤﻞ‬
‫ﻋﻠﻰ ﺟﻠﺐ ﻣﻜﻮﻧﺎت وﻣﺤﺘﻮﯾﺎت ﻧﺎﺗﺞ ﺗﻨﻔﯿﺬ أﻣﺮ اﻻﺳﺘﻌﻼم‪.‬‬
‫اﻟﻤﺜﺎل اﻟﺜﺎﻧﻲ ‪see2.php‬‬

‫‪<?php‬‬
‫‪$dbhost = 'localhost:3306'; /* or use the default: $dbhost = 'localhost';*/‬‬
‫;'‪$dbuser = 'root‬‬
‫;'' = ‪$dbpass‬‬
$conn = mysql_connect($dbhost, $dbuser, $dbpass);
if(! $conn )
{
die('Could not connect: ' . mysql_error());
}
$sql_statement = 'SELECT P_Id, LastName, Address FROM persons';
mysql_select_db('customers');
$retval = mysql_query( $sql_statement, $conn );
if(! $retval )
{
die('Could not get data: ' . mysql_error());
}
while($row = mysql_fetch_array($retval, MYSQL_ASSOC))
{
echo "<br> Person ID :{$row['P_Id']} ";
echo "<br> Last Name : {$row['LastName']} ";
echo "<br> Address : {$row['Address']} ";
echo "<br> ========================= <br> ";
}
echo "<br> Data fetched successfully\n";
mysql_close($conn);
echo "<br> Connection closed \n";
?>
‫ﺧﻄﻮات ﻋﻤﻞ اﻟﺠﺰء اﻟﺜﺎﻟﺚ‬

‫ وذﻟﻚ ﻣﻦ ﻏﯿﺮ واﺟﮭﺔ‬،PHP ‫ اﻟﮭﺪف اﻟﺜﺎﻟﺚ وھﻮ إدﺧﺎل ﺑﯿﺎﻧﺎت إﻟﻰ ﻗﺎﻋﺪة ﺑﯿﺎﻧﺎت ﺗﻢ إﻧﺸﺎﺋﮭﺎ ﻣﺴﺒﻘﺎ ﻣﻦ ﺧﻼل ﺻﻔﺤﺔ‬،‫ﯾﺤﻘﻖ ھﺬا اﻟﺠﺰء‬
‫ ﯾﺘﻢ إدﺧﺎل ﺑﯿﺎﻧﺎت ﺟﺪﯾﺪة إﻟﻰ‬،‫ ﻓﻲ ھﺬا اﻟﻤﺜﺎل‬.‫ اﻟﺘﻲ ﺳﺘﻨﻔﺬ‬sql ‫ اﻟﻔﺮق اﻟﻮﺣﯿﺪ ﻋﻦ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ھﻮ ﻓﻲ ﺟﻤﻠﺔ‬.GUI ‫رﺳﻮﻣﺎت ﺗﺨﺎطﺒﯿﺔ‬
.‫ ﺳﻮف ﺗﺴﺘﺨﺪم ﻓﻲ ھﺬا اﻟﻤﺜﺎل أﯾﻀﺎ‬،‫ ﺑﺎﻟﺘﺎﻟﻲ اﻟﺪوال اﻟﻤﺴﺘﺨﺪﻣﺔ ﻓﻲ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ‬.‫ﻗﺎﻋﺪة اﻟﺒﯿﺎﻧﺎت وﻻ ﯾﺘﻢ ﺟﻠﺐ ﺑﯿﺎﻧﺎت‬
see3.php ‫اﻟﻤﺜﺎل اﻟﺜﺎﻟﺚ‬
<?php
$dbhost = 'localhost:3306';
$dbuser = 'root';
$dbpass = '';
if(! $conn )
‫{‬
‫;))(‪die('Could not connect: ' . mysql_error‬‬
‫}‬
‫‪$sql_statement = 'INSERT INTO Persons (P_Id, LastName, FirstName, Address, City) VALUES (4, "Ameena",‬‬
‫;')"‪"Mahmoud", "Yatta 3", "Hebron‬‬
‫;)'‪mysql_select_db('customers‬‬
‫;) ‪$retval = mysql_query( $sql_statement, $conn‬‬
‫) ‪if(! $retval‬‬
‫{‬
‫;))(‪die('Could not enter data: ' . mysql_error‬‬
‫}‬
‫;"‪echo "<br> Data entered successfully\n‬‬
‫;)‪mysql_close($conn‬‬
‫;"‪echo "<br> Connection Closed \n‬‬
‫>?‬
‫ﺧﻄﻮات ﻋﻤﻞ اﻟﺠﺰء اﻟﺮاﺑﻊ‬

‫ﻓﻲ ھﺬا اﻟﺠﺰء ﺳﯿﺘﻢ إﻧﺸﺎء واﺟﮭﺔ رﺳﻮﻣﺎت ﺗﺨﺎطﺒﯿﺔ ‪ GUI‬ﻣﻊ اﻟﻤﺴﺘﺨﺪم ﻣﻦ ﺧﻼل ﻧﻤﻮذج ‪ ،HTML Form‬ﻛﻤﺎ ھﻮ ﻣﻮﺿﺢ ﻓﻲ‬
‫اﻟﺼﻮرة أدﻧﺎه‪ .‬ﯾﺘﻢ إﻧﺸﺎء اﻟﻮاﺟﮭﺔ اﻟﺘﺨﺎطﺒﯿﺔ ‪ GUI‬ﺑﺎﺳﺘﺨﺪام ﺳﻜﺮﯾﺒﺖ ﻛﻮد ‪ ،HTML‬ﺣﯿﺚ ﻧﻨﺸﺊ ﺣﻘﻞ ﻟﺮﻗﻢ اﻟﺸﺨﺺ )اﻟﺰﺑﻮن(‪ ،‬وﺣﻘﻞ‬
‫ﻷﺳﻤﮫ اﻷﺧﯿﺮ‪ ،‬وﺣﻘﻞ ﻷﺳﻤﮫ اﻷول وﺣﻘﻞ ﻟﻠﻌﻨﻮان وآﺧﺮ ﻟﻠﻤﺪﯾﻨﺔ‪ .‬ﻣﻦ اﺟﻞ رﻓﻊ ‪ upload‬اﻟﻤﻌﻠﻮﻣﺎت إﻟﻰ ﺧﺎدم ﻗﺎﻋﺪة اﻟﺒﯿﺎﻧﺎت‪ ،‬ﻧﻀﯿﻒ‬
‫زر ‪ button‬ﺑﺎﺳﻢ ‪ add‬وﻟﯿﻜﻦ ﻣﻌﺮﻓﮫ ‪ id‬أﯾﻀﺎ ﺑﻨﻔﺲ أﺳﻤﮫ‪ .‬اﻟﺪاﻟﺔ اﻟﺠﺪﯾﺪة اﻟﺘﻲ ﺳﻨﺴﺘﺨﺪﻣﮭﺎ ﻣﻦ ‪ PHP‬ھﻲ ‪ isset‬وھﺬه اﻟﺪاﻟﺔ ﺗﻌﻤﻞ‬
‫ﻋﻠﻰ ﻓﺤﺺ إن ﻛﺎن اﻟﺰر ‪ add‬ﻗﺪ ﺗﻢ ﺿﻐﻄﮫ ﻣﻦ ﻗﺒﻞ اﻟﻤﺴﺘﺨﺪم ﻓﺈﻧﮭﺎ ﺗﻌﯿﺪ ‪ .true‬ﻋﻨﺪھﺎ ﯾﺒﺪأ اﻟﻌﻤﻞ ﻋﻠﻰ ﻓﺘﺢ راﺑﻂ ﻣﻊ ﻗﺎﻋﺪة اﻟﺒﯿﺎﻧﺎت‬
‫ﻋﻠﻰ اﻟﺨﺎدم وﺗﻨﻔﯿﺬ اواﻣﺮ ‪ sql‬ﻛﻤﺎ ﺣﺼﻞ ﻓﻲ اﻷﻣﺜﻠﺔ اﻟﺴﺎﺑﻘﺔ‪.‬‬
‫اﻟﻤﺜﺎل اﻟﺮاﺑﻊ ‪see4.php‬‬

‫>‪<html‬‬
‫>‪<head‬‬
‫>‪<title>Add New Record in MySQL Database</title‬‬
‫>‪</head‬‬
‫>‪<body‬‬
‫‪<?php‬‬
‫))]'‪if(isset($_POST['add‬‬
‫{‬
‫;'‪$dbhost = 'localhost:3306‬‬
$dbuser = 'root';
$dbpass = '';
if(! $conn )
{
}
$id1 = $_POST['id1'];
$LN = $_POST['LN'];
$FN = $_POST['FN'];
$C = $_POST['C'];
$A = $_POST['A'];
$sql="INSERT INTO Persons(P_Id,LastName,FirstName,City,Address) VALUES('$id1','$LN','$FN','$C','$A')";
$retval = mysql_query( $sql, $conn );
if(! $retval )
{
die('Could not enter data: ' . mysql_error());
}
echo "<br> Entered data successfully\n";
mysql_close($conn);
echo "<br> Connection closed\n";
}
else
{
?>
<form method="post" action="<?php $_PHP_SELF ?>">
<table width="400" border="0" cellspacing="1" cellpadding="2">
<tr>
<td width="100">Person Id</td>
<td><input name="id1" type="text" id="id1"></td>
</tr>
<tr>
<td width="100">Last Name</td>
<td><input name="LN" type="text" id="LN"></td>
</tr>
<tr>
<td width="100">First Name</td>
<td><input name="FN" type="text" id="FN"></td>
</tr>
<tr>
<td width="100">Address</td>
<td><input name="A" type="text" id="C"></td>
</tr>
<tr>
<td width="100">City</td>
<td><input name="C" type="text" id="A"></td>
</tr>
<tr>
<td width="100"> </td>
<td> </td>
</tr>
<tr>
<td width="100"> </td>
<td>
<input name="add" type="submit" id="add" value="Add Person">
</td>
</tr>
</table>
</form>
<?php
}
?>
</body></html>
‫ﺧﻄﻮات ﻋﻤﻞ اﻟﺠﺰء اﻟﺨﺎﻣﺲ‬
.‫ ﺳﯿﺘﻢ ﺗﻄﺒﯿﻘﮫ ﻧﻔﺴﮫ ھﻨﺎ أﯾﻀﺎ‬،‫ واﻟﻤﺒﺪأ اﻟﺬي ﺗﻢ اﺳﺘﺨﺪاﻣﮫ ﻓﻲ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ‬،‫ﻻ دوال ﺟﺪﯾﺪة ھﻨﺎ‬
see5.php ‫اﻟﻤﺜﺎل اﻟﺨﺎﻣﺲ‬

‫ واﻟﺬي ﯾﻄﻠﺐ ﻣﻦ اﻟﻤﺴﺘﺨﺪم ﺗﺤﺪﯾﺪ رﻗﻢ اﻟﺸﺨﺺ أو‬،‫ اﻟﺘﺎﻟﻲ‬form ‫ ﻋﻠﻰ إﻧﺸﺎء اﻟﻨﻤﻮذج‬،‫ ﻋﺰﯾﺰي اﻟﺪارس‬،‫ﻓﻲ ھﺬا اﻟﻤﺜﺎل ﺳﺘﻌﻤﻞ‬
.‫)اﻟﺰﺑﻮن( ﻣﻦ اﺟﻞ إﻟﻐﺎء ﺑﯿﺎﻧﺎﺗﮫ ﻛﺎﻓﺔ ﻣﻦ ﻗﺎﻋﺪة اﻟﺒﯿﺎﻧﺎت‬
<html>
<head>
<title>Delete a Record from MySQL Database</title>
</head>
<body>
<?php
if(isset($_POST['delete'])) {
$dbhost = 'localhost:3306';
$dbuser = 'root';
$dbpass = '';
if(! $conn ) {
}
$id1 = $_POST['id1'];
$sql = "DELETE FROM Persons WHERE P_Id = $id1" ;
$retval = mysql_query( $sql, $conn );
echo "<br> $retval\n";
if(! $retval )
{
die('Could not delete data: ' . mysql_error());
}
else
echo "<br> Data deleted successfully\n";
mysql_close($conn);
}
else {
?>
<form method = "post" action = "<?php $_PHP_SELF ?>">
<table width = "400" border = "0" cellspacing = "1" cellpadding = "2">
<tr>
<td width = "100">Person ID</td>
<td><input name = "id1" type = "text" id = "id1"></td>
</tr>
<tr>
<td width = "100"> </td>
<td> </td>
</tr>
<tr>
<td width = "100"> </td>
<td>
<input name = "delete" type = "submit" id = "delete" value = "Delete">
</td>
</tr>
</table>
</form>
<?php
}
?>
</body>
</html>
‫اﻟﻨﺸﺎط اﻟﺼﻔﻲ اﻟﺴﺎدس‬
‫اﺳﺘﺪﻋﺎء اﻹﺟﺮاء ﻋﻦ ﺑﻌﺪ ﺑﻠﻐﺔ ﺑﻲ اش ﺑﻲ‬

‫‪XML RPC with PHP‬‬
‫اﻟﺮﺑﻂ ﻣﻊ اﻹﺟﺮاءات ﻋﻦ ﺑﻌﺪ )‪ ،Remote Procedure Call (RPC‬ھﻲ ﺗﻘﻨﯿﺔ اﺗﺼﺎل ﺳﮭﻠﺔ وﺑﺴﯿﻄﺔ ﺗﻤﻜﻦ اﻟﻤﺒﺮﻣﺞ ﻣﻦ اﻻﺗﺼﺎل‬
‫ﺑﯿﻦ ﺧﺎدم وﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﺰﺑﺎﺋﻦ ﯾﻌﻤﻠﻮن ﻋﻠﻰ ﻣﻨﺼﺎت ‪ platform‬ﻣﺨﺘﻠﻔﺔ )ﻧﻈﻢ ﺗﺸﻐﯿﻞ ﻣﺨﺘﻠﻔﺔ( ﺑﺤﯿﺚ ﺗﻮﻓﺮ ﺑﯿﺌﺔ ﻣﺤﻮﺳﺒﺔ ﻣﻮزﻋﺔ‬
‫ﻣﺘﻌﺪدة اﻟﻤﻨﺼﺎت )‪ (Cross–Platform Distributed Computing‬ﺑﺎﻻﻋﺘﻤﺎد ﻋﻠﻰ ﺑﺮوﺗﻮﻛﻮل ﻧﻘﻞ اﻟﻨﺼﻮص ﻓﻲ اﻻﻧﺘﺮﻧﺖ‬
‫‪ .HTTP‬وﺑﻤﺎ أن ﻟﻐﺔ ‪ PHP‬ﺗﺴﺘﺨﺪم ﺑﺮوﺗﻮﻛﻮل ‪ HTTP‬ﻟﻠﻨﻘﻞ‪ ،‬وﻟﻐﺔ ‪ XML‬ﻟﻠﺸﯿﻔﺮة ‪ ،encoding‬ﻓﺈن ھﺬا ﯾﺴﻤﺢ ﻧﻘﻞ ﺗﺮاﻛﯿﺐ ﺑﯿﺎﻧﺎت‬
‫ﻣﻌﻘﺪة ‪ complex data structures‬ﺑﯿﻦ اﻟﻌﻘﺪ ﻓﻲ اﻟﺸﺒﻜﺔ وھﺬه اﻟﻄﺮﯾﻘﺔ ﺗﺴﻤﻰ ‪ XML-RPC‬ﻓﻲ ﻟﻐﺔ ‪ .PHP‬ﺑﺎﻟﺘﺎﻟﻲ ﯾﻤﻜﻦ ﻟﺰﺑﻮن‬
‫‪ client‬ﯾﻌﻤﻞ ﻋﻠﻰ ﺟﮭﺎزه ﻣﻦ ﻧﻮع ‪ ،Dell‬ﺑﻤﻨﺼﺔ ﻧﻈﺎم وﯾﻨﺪوز‪ ،‬أن ﯾﺘﺼﻞ ﻣﻊ ﺧﺎدم ﯾﻌﻤﻞ ﻋﻠﻰ ﺟﮭﺎز ﻧﻮع ‪ ،HP‬ﺑﻤﻨﺼﺔ ﻧﻈﺎم ﻟﯿﻨﻮﻛﺲ‬
‫‪ ،Linux‬وﯾﺘﺒﺎدل اﻟﺒﯿﺎﻧﺎت ﻣﻊ اﻟﺨﺎدم أﯾﻀﺎ ﺑﻔﻀﻞ وﺳﯿﻠﺔ اﻻﺗﺼﺎل ‪ XML-RPC‬ﺑﺎﺳﺘﺨﺪام ﺑﺮوﺗﻮﻛﻮل ‪ .HTTP‬وﻟﻜﻦ ھﺬا ﯾﺘﻄﻠﺐ‬
‫وﺟﻮد ﺷﺒﻜﺔ ﺗﺪﻋﻢ ﺑﺮوﺗﻮﻛﻮل اﻻﺗﺼﺎل ‪ HTTP‬ﻣﺜﻞ اﻻﻧﺘﺮﻧﺖ أو اﻻﻧﺘﺮاﻧﺖ ‪.Internet/Intranet‬‬
‫أن ﺗﺘﻌﺮف ﻋﻠﻰ ﺗﻘﻨﯿﺔ اﻻﺗﺼﺎل ‪ RPC‬ﻓﻲ ﻟﻐﺔ ‪ PHP‬واﻟﺘﻲ ﺗﻐﻠﻔﮭﺎ ﺑﻠﻐﺔ ‪ ،XML‬أي ‪.XML-RPC‬‬ ‫‪.1‬‬
‫أن ﺗﺘﻌﺮف ﻋﻠﻰ اﻟﺪوال اﻟﻤﻜﺘﻮﺑﺔ ﺑﻠﻐﺔ ‪ PHP‬واﻟﺘﻲ ﺗﺴﮭﻞ ﻋﻠﻰ اﻟﻤﺒﺮﻣﺞ اﻻﺗﺼﺎل ﺑﺘﻘﻨﯿﺔ ‪.XML-RPC‬‬ ‫‪.2‬‬
‫أن ﺗﻜﺘﺐ ﺑﻠﻐﺔ ‪ PHP‬ﺑﺮﻧﺎﻣﺞ ﯾﻤﺜﻞ ﺧﺎدم وﺑﺮﻧﺎﻣﺞ آﺧﺮ ﯾﻤﺜﻞ زﺑﻮن‪ ،‬ﺗﻨﻔﺬ اﻟﺒﺮﻧﺎﻣﺠﯿﻦ ﻣﻦ ﺧﻼل ﺟﮭﺎز ّ‬
‫ي ﺣﺎﺳﻮب اﺛﻨﯿﻦ‪ ،‬وﺳﯿﻠﺔ‬ ‫‪.3‬‬
‫اﻻﺗﺼﺎل ﺑﯿﻨﮭﻤﺎ ھﻲ ‪.XML-RPC‬‬
‫أن ﺗﻌﻤﻞ ﻋﻠﻰ ﺗﻄﻮﯾﺮ اﻟﺒﺮﻧﺎﻣﺠﯿﻦ اﻟﺴﺎﺑﻘﯿﻦ ﺑﺤﯿﺚ ﯾﻘﻮم اﻟﺨﺎدم ﺑﺎﻟﺮﺑﻂ ﻣﻊ ﻗﺎﻋﺪة ﺑﯿﺎﻧﺎت ﻟﯿﻠﺒﻲ اﺣﺘﯿﺎﺟﺎت طﻠﺐ اﻟﺰﺑﻮن‪.‬‬ ‫‪.4‬‬

‫ﻓﻲ ھﺬا اﻟﺠﺰء‪ ،‬ﺳﺘﺘﻌﺮف‪ ،‬ﻋﺰﯾﺰي اﻟﺪارس‪ ،‬ﻋﻠﻰ ﺗﻘﻨﯿﺔ اﻻﺗﺼﺎل ‪ RPC‬ﻓﻲ ﻟﻐﺔ ‪ PHP‬واﻟﺘﻲ ﺗﻐﻠﻔﮭﺎ ﺑﻠﻐﺔ ‪ ،XML‬أي ‪.XML-RPC‬‬
‫ﺛﻢ ﺳﺘﺘﻌﺮف ﻋﻠﻰ اﻟﺪوال اﻟﻤﻜﺘﻮﺑﺔ ﺑﻠﻐﺔ ‪ PHP‬واﻟﺘﻲ ﺗﺴﮭﻞ اﻻﺗﺼﺎل ﺑﺘﻘﻨﯿﺔ ‪ .XML-RPC‬وأﺧﯿﺮاً ﺳﺘﻜﺘﺐ ﺑﻠﻐﺔ ‪ PHP‬ﺑﺮﻧﺎﻣﺞ ﯾﻤﺜﻞ‬
‫ﺧﺎدم وﺑﺮﻧﺎﻣﺞ آﺧﺮ ﯾﻤﺜﻞ زﺑﻮن‪ ،‬ﺗﻨﻔﺬ اﻟﺒﺮﻧﺎﻣﺠﯿﻦ ﻣﻦ ﺧﻼل ﺟﮭﺎز ّ‬
‫ي ﺣﺎﺳﻮب اﺛﻨﯿﻦ‪ ،‬ﺑﻮﺳﺎطﺔ ﺗﻘﻨﯿﺔ ‪ .XML-RPC‬ﺑﺎﻟﺘﺎﻟﻲ ﺳﻮف ﯾﺘﻢ‬
‫ﺗﺤﻘﯿﻖ اﻷھﺪاف اﻟﺜﻼﺛﺔ اﻷوﻟﻰ اﻟﻤﺬﻛﻮرة أﻋﻼه‪.‬‬
‫اﻟﻤﻠﻒ اﻷول‪service.php :‬‬
‫ﯾﻤﺜﻞ ھﺬا اﻟﺒﺮﻧﺎﻣﺞ ﺧﺎدﻣﺎ ﺑﺴﯿﻄﺎ ﯾﻌﻤﻞ ﻋﻠﻰ اﻟﺮد ﻋﻠﻰ اﺳﺘﻔﺴﺎر ﻣﻦ زﺑﻮن‪ .‬ﻓﯿﺴﺘﻘﺒﻞ رﻗﻤﺎ ﻣﻦ اﻟﺰﺑﻮن وﯾﻘﻮم ﺑﻀﺮﺑﮫ ﺑﺎﻟﺮﻗﻢ "‪ "8‬ﺛﻢ ﯾﻌﯿﺪ‬
‫اﻟﻨﺎﺗﺞ إﻟﻰ ﺷﺎﺷﺔ اﻟﺰﺑﻮن‪.‬‬
‫‪<?php‬‬
‫‪$request_xml = file_get_contents("php://input"); #inputstream‬‬
‫)‪function databases($method_name, $args, $app_data‬‬
‫{‬
‫;]‪$username = $args[0‬‬
‫;]‪$password = $args[1‬‬
‫‪$x1‬‬ ‫;]‪= $args[2‬‬
‫‪/*Perform authentication and authorization here. If failed return a fault code or exit*/‬‬
‫‪/* You may connect to databases and retrieve data here */‬‬
‫;‪return $x1*6‬‬
‫}‬
‫;)(‪$xmlrpc_server = xmlrpc_server_create‬‬
‫;)"‪xmlrpc_server_register_method($xmlrpc_server, "databases", "databases‬‬
‫;)'‪header('Content-Type: text/xml‬‬
‫‪print‬‬
‫;))(‪xmlrpc_server_call_method($xmlrpc_server, $request_xml, array‬‬
‫>?‬
‫ﺗﻢ إﻧﺸﺎء اﻟﺪاﻟﺔ اﻟﺘﻲ ﺳﯿﻘﻮم اﻟﺰﺑﻮن ﺑﻤﻨﺎداﺗﮭﺎ وھﻲ ﺑﺄﺳﻢ ‪ ،databases‬ﺣﯿﺚ ﯾﺘﻢ ﺗﻤﺮﯾﺮ ﺛﻼث ﻣﺘﻐﯿﺮات ﻟﮭﺎ‪ ،‬ﯾﻤﺜﻞ اﻟﻤﺘﻐﯿﺮ اﻷول أﺳﻢ‬
‫اﻟﺪاﻟﺔ ‪ ،method_name‬واﻟﻤﺘﻐﯿﺮ اﻟﺜﺎﻧﻲ ﻋﺒﺎرة ﻋﻦ ﻣﺼﻔﻮﻓﺔ ﻣﻦ اﻟﻤﺘﻐﯿﺮات ﺗﺤﻤﻞ أﺳﻢ اﻟﻤﺴﺘﺨﺪم ‪ ،username‬وﻛﻠﻤﺔ اﻟﺴﺮ‬
‫‪ ،password‬واﻟﻤﺘﻐﯿﺮ اﻟﺜﺎﻟﺚ ﯾﺤﻤﻞ اﻟﺮﻗﻢ اﻟﺬي ﺳﯿﺘﻢ ﺿﺮﺑﮫ ب "‪."8‬‬
‫ﺗﺴﮭﻞ ﻟﻐﺔ ‪ PHP‬ﻋﻠﻰ اﻟﻤﺒﺮﻣﺞ إﻧﺸﺎء ﺧﺎدم ﻣﻦ ﺧﻼل اﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ )(‪ xmlrpc_server_create‬واﻟﺘﻲ ﺗﻌﯿﺪ ﺧﺎدم ﻋﻠﻰ ﺷﻜﻞ‬
‫ﻣﺼﺪر ‪ .resource‬وﺑﻤﺎ أﻧﻨﺎ ﻧﺴﺘﺨﺪم ﺑﺮوﺗﻮﻛﻮل ‪ HTTP‬ﻟﻠﻨﻘﻞ‪ ،‬ﻓﺈن طﺮق ھﺬا اﻟﺒﺮوﺗﻮﻛﻮل ھﻲ اﻟﺘﻲ ﺳﻮف ﺗﺴﺘﺨﺪم‪ ،‬وﻣﻨﮭﺎ ‪ get‬ﻓﻲ‬
‫ﺣﺎﻟﺔ اﻟﺨﺎدم ﻻﺳﺘﻘﺒﺎل اﻟﻄﻠﺐ ‪ request‬ﻣﻦ ﺧﻼل اﻟﺪاﻟﺔ ‪ ،file_get_contents‬وﻛﺬﻟﻚ ‪ post‬ﻓﻲ ﺣﺎﻟﺔ اﻟﺰﺑﻮن ﻣﻦ اﺟﻞ إرﺳﺎل اﻟﻄﻠﺐ‬
‫‪ .request‬ﻟﺬﻟﻚ ﺗﻢ ﺗﻌﺮﯾﻒ ﻣﺘﻐﯿﺮ ﺑﺄﺳﻢ ‪ $request_xml‬ﯾﻌﻤﻞ ﻋﻠﻰ ﺗﺤﺪﯾﺪ ‪ get‬ﻻﺳﺘﻘﺒﺎل اﻟﺒﯿﺎﻧﺎت ﻣﻦ ﺧﻼل اﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ‬
‫‪ xmlrpc_encode_request‬واﻟﺘﻲ ﺗﻌﻤﻞ ﻋﻠﻰ ﻗﺮاءة اﻟﺒﯿﺎﻧﺎت اﻟﻤﺮﺳﻠﺔ وﻓﻚ ﺷﻔﺮة ‪ XML‬ﻟﻠﺤﺼﻮل ﻋﻠﻰ ﺗﻠﻚ اﻟﺒﯿﺎﻧﺎت‪.‬‬
‫ﻣﻦ أﺟﻞ اﻟﺘﻌﺮف ﻋﻠﻰ اﻟﺪاﻟﺔ اﻟﺘﻲ ﺗﻨﻔﺬ ﻋﻦ ﺑﻌﺪ‪ ،‬ﻻ ﺑ ّﺪ ﻣﻦ ﺗﺴﺠﯿﻞ ﺗﻠﻚ اﻟﺪاﻟﺔ ﻓﻲ ﻗﺎﻋﺪة ﺑﯿﺎﻧﺎت اﻟﺨﺎدم ﻣﻦ ﺧﻼل اﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ‬
‫;)‪ xmlrpc_server_register_method(resource $server, string $method_name, string $function‬واﻟﺘﻲ ﺗﺄﺧﺬ‬
‫ﺛﻼﺛﺔ ﻣﻌﺎﻣﻼت‪ ،‬أﺳﻢ اﻟﺨﺎدم اﻟﺬي ﺗﻢ إﻧﺸﺎؤه‪ ،‬وأﺳﻢ اﻟﻄﺮﯾﻘﺔ اﻟﺘﻲ ﺗﻮاﻓﻖ اﺳﻢ اﻟﺪاﻟﺔ اﻟﻤﻨﺎداة وھﻲ ﻧﻔﺴﮭﺎ اﻟﻤﻌﺎﻣﻞ اﻷﺧﯿﺮ‪.‬‬
‫ﯾﺘﻢ اﻟﺮد ﻋﻠﻰ اﻟﺰﺑﻮن ﺑﺎﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ ‪ print‬ﻟﺘﻄﺒﻊ ﻋﻠﻰ اﻟﺒﺮوﺗﻮﻛﻮل ﻧﺘﯿﺠﺔ ﺗﻨﻔﯿﺬ اﻟﺪاﻟﺔ‬
‫;))(‪ ،xmlrpc_server_call_method($xmlrpc_server, $request_xml, array‬واﻟﺘﻲ ﺗﺄﺧﺬ ﺛﻼث ﻣﻌﺎﻣﻼت‪ ،‬ﻣﺼﺪر‬
‫اﻟﺨﺎدم ‪ ،resource $server‬اﻟﻄﻠﺐ ﻋﻠﻰ ﺷﻜﻞ ﺷﯿﻔﺮة ‪ xml‬واﻟﻤﻌﺎﻣﻼت اﻟﺘﻲ ﺳﯿﺘﻢ ارﺟﺎﻋﮭﺎ ﻋﻠﻰ ﺷﻜﻞ ﻣﺼﻔﻮﻓﺔ‪.‬‬
‫ﺳﺆال ‪ :1‬أذﻛﺮ ﺧﻄﻮات إﻧﺸﺎء ﺧﺎدم ‪ ،XML-RPC‬ﻓﻲ ﻟﻐﺔ ‪PHP‬؟‬
‫اﻟﺒﺮﻧﺎﻣﺞ اﻟﺜﺎﻧﻲ ‪client.php‬‬
‫ﻣﻦ ﺟﮭﺔ اﻟﺰﺑﻮن‪ ،‬ﯾﺠﺐ ﻣﻨﺎداة اﻟﺪاﻟﺔ اﻟﺘﻲ ﺗﻌﻤﻞ ﻋﻠﻰ إﻧﺸﺎء دﻓﻖ ‪ stream‬ﻟﻠﻤﺤﺘﻮى ‪ context‬وھﻲ اﻟﺪاﻟﺔ‬
‫)))(‪ ،stream_context_create(array('http' => array‬واﻟﺘﻲ ﺗﺄﺧﺬ ﻣﻌﺎﻣﻞ ﻋﻠﻰ ﺷﻜﻞ ﻣﺼﻔﻮﻓﺔ‪ ،‬ﺗﺤﺪد ﻛﻞ ﻣﻦ ﺑﺮوﺗﻮﻛﻮل‬
‫اﻻﺗﺼﺎل وھﻮ ‪ HTTP‬و ﻛﺬﻟﻚ ﻣﻌﺎﻣﻼت ھﺬا اﻟﺒﺮوﺗﻮﻛﻮل‪ .‬ﻓﻄﺮﯾﻘﺔ اﻻرﺳﺎل ھﻲ ‪ POST‬ﻛﻤﺎ ذﻛﺮ أﻋﻼه‪ ،‬واﻟﺮأﺳﯿﺔ ‪ ،header‬ﺗﻮﺿﺢ‬
‫أن ﻧﻮع اﻟﻤﺤﺘﻮى ھﻮ ﻧﺼﻮص ‪ xml‬أو ‪ ،text/xml‬وأن ﻋﺎﻣﻞ اﻟﻤﺴﺘﺨﺪم ‪ User-Agent‬ھﻮ ﺗﻘﻨﯿﺔ اﻻﺗﺼﺎل ‪ RPC‬ﻣﻦ ﺧﻼل ﻟﻐﺔ‬
‫‪ PHP‬أو ‪.PHPRPC‬‬
‫‪<?php‬‬
‫;))‪$request = xmlrpc_encode_request("databases", array('username', 'password', 8‬‬
‫(‪$context = stream_context_create(array('http' => array‬‬
‫‪'method' => "POST",‬‬
‫‪'header' => "Content-Type: text/xml\r\nUser-Agent: PHPRPC/1.0\r\n",‬‬
‫‪'content' => $request‬‬
‫;)))‬
‫‪/*This URL may not exist. Replace it with your server URL*/‬‬
‫;'‪$server = 'http://localhost/xampp/tutorial/service.php‬‬
‫;)‪$file = file_get_contents($server, false, $context‬‬
‫;)‪$response = xmlrpc_decode($file‬‬
‫;‪echo "Result= " . $response‬‬
‫>?‬
‫اﻵن ﯾﺠﺐ طﺒﺎﻋﺔ اﻟﻨﺎﺗﺞ ﻋﻠﻰ ﺷﺎﺷﺔ اﻟﺰﺑﻮن ﻛﻤﺎ ھﻮ ﻣﺒﯿﻦ ﻓﻲ اﻟﺼﻮرة أدﻧﺎه‪ .‬ﯾﺘﻢ ذﻟﻚ ﻣﻦ ﺧﻼل ﻣﻨﺎداة اﻟﺪاﻟﺔ )(‪$xmlrpc_decode‬‬
‫واﻟﺘﻲ ﺗﺄﺧﺬ ﻣﻌﺎﻣﻞ ﻋﻠﻰ ﺷﻜﻞ ﻣﻠﻒ ﯾﺤﺪد طﺮﯾﻘﺔ اﻟﺤﺼﻮل ﻋﻠﻰ اﻟﻤﺤﺘﻮى ﺟﮭﺔ اﻟﺨﺎدم وھﻲ ‪ .get‬ﯾﺘﻢ ﺗﻌﺮﯾﻒ ھﺬا اﻟﻤﻌﺎﻣﻞ ﻣﻦ ﺧﻼل‬
‫اﻟﺪاﻟﺔ )(‪ ،get_file_contents‬واﻟﺘﻲ ﺗﻌﯿﺪ ﻣﺎ ﺗﻘﺮأه ﻣﻦ ﺑﯿﺎﻧﺎت اﻟﻤﻠﻒ ﻋﻠﻰ ﺷﻜﻞ ﺳﻠﺴﻠﺔ ‪ ،string‬وﻟﻜﻨﮭﺎ ﺗﺄﺧﺬ ﺑﺪورھﺎ ﺛﻼث ﻣﻌﺎﻣﻼت‪،‬‬
‫اﻟﻤﻌﺎﻣﻞ اﻷول ھﻮ أﺳﻢ اﻟﺨﺎدم‪ ،‬واﻟﻤﻌﺎﻣﻞ اﻟﺜﺎﻧﻲ ‪ false‬ﻟﻌﺪم ﺗﺤﺪﯾﺪ اﻟﻤﺴﺎر‪ ،‬واﻟﺜﺎﻟﺚ اﻟﻤﺤﺘﻮى ‪ context‬اﻟﺬي ﺗﻢ إﻧﺸﺎؤه ﺳﺎﺑﻘﺎ‪.‬‬
‫ﻣﻼﺣﻈﺔ‪ :‬اﺳﺘﺒﺪل اﺳﻢ اﻟﺠﮭﺎز اﻟﻤﺤﻠﻲ ‪ ،localhost‬ﺑﺎﺳﻢ اﻟﺠﮭﺎز اﻟﺬي ﯾﻮﺟﺪ ﻋﻠﯿﮫ اﻟﺨﺎدم‪ .‬ﯾﻤﻜﻨﻚ اﻻﺳﺘﻌﺎﻧﺔ ﺑﻤﺸﺮف اﻟﻤﺨﺘﺒﺮ ﻟﯿﻌﻄﯿﻚ‬
‫اﺳﻢ اﻟﺠﮭﺎز‪.‬‬
‫ﺳﺆال ‪ :2‬أذﻛﺮ ﺧﻄﻮات إﻧﺸﺎء زﺑﻮن ‪ ،XML-RPC‬ﻓﻲ ﻟﻐﺔ ‪PHP‬؟‬

‫ﻓﻲ ھﺬا اﻟﺠﺰء‪ ،‬ﺳﺘﻌﻤﻞ ﻋﺰﯾﺰي اﻟﺪارس ﻣﻦ ﺧﻼل اﻟﺘﺪرﯾﺐ اﻟﺘﺎﻟﻲ ﻋﻠﻰ رﺑﻂ اﻟﺨﺎدم ‪ server‬ﻣﻊ ﻗﺎﻋﺪة ﺑﯿﺎﻧﺎت ﺑﺤﯿﺚ ﯾﻄﻠﺐ اﻟﺰﺑﻮن‬
‫‪ client‬ﺑﯿﺎﻧﺎت ﻣﻦ اﻟﺨﺎدم‪ ،‬ﻓﯿﻘﻮم اﻟﺨﺎدم ﺑﺈﻋﺎدة ﺗﻠﻚ اﻟﺒﯿﺎﻧﺎت ﻣﻦ ﻗﺎﻋﺪة ﺑﯿﺎﻧﺎت ﺗﻢ إﻧﺸﺎؤھﺎ ﻣﺴﺒﻘﺎ‪.‬‬
‫ﺗﺪرﯾﺐ ‪ :1‬اﻋﻤﻞ ﻋﻠﻰ إﺿﺎﻓﺔ اﻟﺠﺰء اﻟﺒﺮﻣﺠﻲ اﻟﺨﺎص ﺑﻚ ﻟﻜﻞ ﻣﻦ ﺑﺮﻧﺎﻣﺞ اﻟﺨﺎدم وﺑﺮﻧﺎﻣﺞ اﻟﺰﺑﻮن ﺑﺤﯿﺚ ﯾﻄﻠﺐ اﻟﺰﺑﻮن‪ ،‬طﺎﻟﺐ ﺟﺎﻣﻌﻲ‬
‫ﻓﺮﺿﺎ‪ ،‬ﺟﻠﺐ ﻋﻼﻣﺎﺗﮫ ﻣﻦ اﻟﺨﺎدم‪ .‬اﻧﻈﺮ اﻟﺼﻮرة أدﻧﺎه‪.‬‬
‫اﻟﻨﺸﺎط اﻟﺼﻔﻲ اﻟﺴﺎﺑﻊ‬
‫رﺑﻂ ﺧﻮادم ‪ RMI‬و ‪ CORBA‬ﺑﻘﻮاﻋﺪ‬

‫اﻟﺒﯿﺎﻧﺎت ‪MySQL‬‬
‫إن ﻣﺼﺪر ﻗﻮة ﺑﺮوﺗﻮﻛﻮل اﻻﺗﺼﺎل ﺳﻮاء ﻛﺎن ‪ RMI‬أو ‪ CORBA‬أو ‪ ،RPC‬ﺗﻜﻤﻦ ﻓﻲ رﺑﻂ ﺧﺎدﻣﮫ ﺑﻘﺎﻋﺪة ﺑﯿﺎﻧﺎت‪ .‬ﻓﻲ ھﺬه اﻟﺘﺠﺮﺑﺔ‪،‬‬
‫ﺳﺘﻘﻮم ﻋﺰﯾﺰي اﻟﺪارس ﺑﺎﺳﺘﺨﺪام ﻧﻔﺲ اﻟﺒﺮاﻣﺞ اﻟﺘﻲ ﻛﺘﺒﺘﮭﺎ ﻓﻲ اﻟﺘﺠﺮﺑﺘﯿﻦ اﻷوﻟﻰ واﻟﺜﺎﻧﯿﺔ ﻣﻦ أﺟﻞ رﺑﻂ اﻟﺨﺎدم ﺑﻘﺎﻋﺪة اﻟﺒﯿﺎﻧﺎت‬
‫‪ .customers‬وﻟﻜﻦ ﻻ ﺑﺪ ﻣﻦ أن ﺗﺘﻌﺮف أوﻻ ﻋﻠﻰ طﺮﯾﻘﺔ اﻟﺮﺑﻂ ﺑﯿﻦ ﻟﻐﺔ اﻟﺒﺮﻣﺠﺔ ﺟﺎﻓﺎ‪ ،‬وﻗﺎﻋﺪة اﻟﺒﯿﺎﻧﺎت ‪ customers‬ﻓﻲ ‪.MySQL‬‬
‫أن ﺗﺘﻌﺮف ﻋﻠﻰ طﺮﯾﻘﺔ ﺟﺎﻓﺎ ﻓﻲ اﻟﺮﺑﻂ ﻣﻊ ﻗﻮاﻋﺪ اﻟﺒﯿﺎﻧﺎت ‪.MySQL‬‬ ‫‪.1‬‬
‫أن ﺗﺘﻌﺮف ﻋﻠﻰ اﻟﻄﺮق ‪ methods‬واﻷﺻﻨﺎف ‪ classes‬اﻟﺘﻲ ﺗﻌﺮﻓﮭﺎ ﺟﺎﻓﺎ ﻟﻠﺮﺑﻂ ﻣﻊ ﻗﻮاﻋﺪ اﻟﺒﯿﺎﻧﺎت ‪.MySQL‬‬ ‫‪.2‬‬
‫ي ﺣﺎﺳﻮب اﺛﻨﯿﻦ‪،‬‬‫أن ﺗﻜﺘﺐ ﺑﻠﻐﺔ ‪ Java‬ﺑﺮﻧﺎﻣﺠﺎ ﯾﻤﺜﻞ ﺧﺎدم وﺑﺮﻧﺎﻣﺠﺎ آﺧﺮ ﯾﻤﺜﻞ زﺑﻮن‪ ،‬ﺗﻨﻔﺬ اﻟﺒﺮﻧﺎﻣﺠﯿﻦ ﻣﻦ ﺧﻼل ﺟﮭﺎز ّ‬ ‫‪.3‬‬
‫وﺳﯿﻠﺔ اﻻﺗﺼﺎل ﺑﯿﻨﮭﻤﺎ ھﻲ ‪ ،RMI‬ﺣﯿﺚ ﯾﺮﺗﺒﻂ ﺧﺎدم ‪ RMI‬ﻣﻊ ﻗﺎﻋﺪة اﻟﺒﯿﺎﻧﺎت‪.‬‬
‫أن ﺗﻜﺘﺐ ﺑﻠﻐﺔ ‪ Java‬ﺑﺮﻧﺎﻣﺠﺎ ﯾﻤﺜﻞ ﺧﺎدم وﺑﺮﻧﺎﻣﺠﺎ آﺧﺮ ﯾﻤﺜﻞ زﺑﻮن‪ ،‬ﺗﻨﻔﺬ اﻟﺒﺮﻧﺎﻣﺠﯿﻦ ﻣﻦ ﺧﻼل ﺟﮭﺎزيّ ﺣﺎﺳﻮب اﺛﻨﯿﻦ‪،‬‬ ‫‪.4‬‬
‫وﺳﯿﻠﺔ اﻻﺗﺼﺎل ﺑﯿﻨﮭﻤﺎ ھﻲ ‪ ،CORBA‬ﺣﯿﺚ ﯾﺮﺗﺒﻂ ﺧﺎدم ‪ CORBA‬ﻣﻊ ﻗﺎﻋﺪة اﻟﺒﯿﺎﻧﺎت‪.‬‬

‫ﻓﻲ ھﺬا اﻟﺠﺰء‪ ،‬ﺳﺘﺘﻌﺮف‪ ،‬ﻋﺰﯾﺰي اﻟﺪارس‪ ،‬ﻋﻠﻰ طﺮﯾﻘﺔ رﺑﻂ ﺟﺎﻓﺎ ﻣﻊ ﻗﺎﻋﺪة اﻟﺒﯿﺎﻧﺎت اﻟﺘﻲ ﺗﻢ إﻧﺸﺎؤھﺎ ﻣﺴﺒﻘﺎ ﺑﺎﺳﻢ ‪ customers‬ﻓﻲ‬
‫‪.MySQL‬‬
‫اﻟﻤﻠﻒ اﻷول‪Connector_mysql.java :‬‬
‫ﯾﻮﺿﺢ ھﺬا اﻟﺒﺮﻧﺎﻣﺞ طﺮﯾﻘﺔ رﺑﻂ ﺟﺎﻓﺎ ﻣﻊ ‪ ،MySQL‬ﺑﺎﺳﺘﺨﺪام طﺮﯾﻘﺔ اﻟﺮﺑﻂ اﻟﻤﻌﯿﺎرﯾﺔ وھﻲ ‪ .Connector/J‬ﯾﺠﺐ ﺗﺤﻤﯿﻞ ھﺬا‬
‫اﻟﻤﻠﻒ اﻟﻤﻀﻐﻮط ﻣﻦ اﻟﻤﻮﻗﻊ اﻟﺘﺎﻟﻲ ‪ .http://dev.mysql.com/downloads/file/?id=462850‬ﻗﻢ ﺑﻔﻚ ﺿﻐﻂ اﻟﻤﻠﻒ‪ ،‬ﻋﻠﻰ‬
‫ﻣﺠﻠﺪ ﻣﻌﯿﻦ ﻟﺤﯿﻦ اﻟﺨﻄﻮة اﻟﺘﺎﻟﯿﺔ‪.‬‬
‫ﺛﻢ وﺑﻌﺪ ذﻟﻚ اﻓﺘﺢ ﺑﺮﻣﺠﯿﺔ ‪ ،NetBeans IDE‬أﻏﻠﻖ ﺟﻤﯿﻊ اﻟﻤﺸﺎرﯾﻊ اﻟﻤﻔﺘﻮﺣﺔ إن وﺟﺪ‪ ،‬واﻋﻤﻞ ﻋﻠﻰ إﻧﺸﺎء ﻣﺸﺮوع ﺟﺪﯾﺪ‪ .‬أﻋﻂ أﺳﻢ‬
‫ﻟﻠﺤﺰﻣﺔ ‪ ،connector_mysql‬ﻣﺒﻘﯿﺎ ﻋﻠﻰ اﻻﻓﺘﺮاﺿﺎت وﻣﻨﮭﺎ أﺳﻢ اﻟﺼﻨﻒ إن أردت ‪ Connector_mysql‬وﻣﻨﮭﺞ ‪ .main‬اﻧﺴﺦ‬
‫اﻟﺒﺮﻧﺎﻣﺞ اﻟﺘﺎﻟﻲ ﻓﻲ داﺧﻞ اﻟﺼﻔﺤﺔ أن أﺑﻘﯿﺖ ﻋﻠﻰ اﻟﻤﺴﻤﯿﺎت اﻟﺴﺎﺑﻘﺔ‪ .‬اﻵن اﻋﻤﻞ ﻋﻠﻰ إﺿﺎﻓﺔ ﻣﻜﺘﺒﺔ إﻟﻰ اﻟﻤﻜﺘﺒﺎت ‪ libraries‬ﻣﻦ ﺧﻼل‬
‫ﺟﻠﺐ ﻣﻠﻒ ‪.jar‬‬
‫ﺛﻢ اﺧﺘﺎر ﻣﻠﻒ ‪ mysql-connector-java-5.1.39-bin.jar‬ﻣﻦ داﺧﻞ اﻟﻤﺠﻠﺪ اﻟﺬي ﻗﻤﺖ ﺑﻔﻚ ﺿﻐﻄﮫ‪.‬‬
package connector_mysql;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
/**
* @author Dr. Eng. Samer Jaloudi
* QOU, Nablus, Palestine
*/
public class Connector_mysql
{
public static void main(String[] args)
{
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
try
{
Class.forName("com.mysql.jdbc.Driver").newInstance();
String connectionUrl = "jdbc:mysql://localhost:3306/customers";
String connectionUser = "root";
String connectionPassword = "";
conn = DriverManager.getConnection(connectionUrl, connectionUser, connectionPassword);
stmt = conn.createStatement();
rs = stmt.executeQuery("SELECT * FROM persons");
while (rs.next())
‫{‬
‫;)"‪String id = rs.getString("P_ID‬‬
‫;)"‪String firstName = rs.getString("FirstName‬‬
‫;)"‪String lastName = rs.getString("LastName‬‬
‫;)"‪String address = rs.getString("Address‬‬
‫;)"‪String city = rs.getString("City‬‬
‫;)‪System.out.print("ID: " + id + ", First Name: " + firstName + ", Last Name: " + lastName‬‬
‫;)‪System.out.println(", address: " + address + ", city: " + city‬‬
‫}‬
‫}‬
‫};)(‪catch (Exception e){e.printStackTrace‬‬
‫‪finally‬‬
‫{‬
‫} ;)(‪try { if (rs != null) rs.close(); } catch (SQLException e) { e.printStackTrace‬‬
‫} ;)(‪try { if (stmt != null) stmt.close(); } catch (SQLException e) { e.printStackTrace‬‬
‫} ;)(‪try { if (conn != null) conn.close(); } catch (SQLException e) { e.printStackTrace‬‬
‫}‬
‫}‬
‫}‬
‫اﻟﺨﻄﻮات اﻟﺘﻲ ﯾﺠﺐ إﺗﺒﺎﻋﮭﺎ ﻓﻲ اﻟﺮﺑﻂ ﻣﻊ ﻗﺎﻋﺪة ﺑﯿﺎﻧﺎت ﻟﺠﻠﺐ ﺑﯿﺎﻧﺎت ﻣﻨﮭﺎ‪:‬‬
‫‪ .1‬أﻧﺸﺊ ﻣﺜﯿﻞ ﻣﻦ أداة اﻟﺮﺑﻂ ﻣﻊ ﻗﺎﻋﺪة اﻟﺒﯿﺎﻧﺎت ‪ Connection‬ﺑﺈﺳﻢ ‪ ،conn‬وﻣﺜﯿﻞ ﻣﻦ ﺟﻤﻠﺔ ﻗﺎﻋﺪة اﻟﺒﯿﺎﻧﺎت ‪ Statement‬ﺑﺈﺳﻢ‬
‫‪ ،stmt‬وﻣﺜﯿﻞ آﺧﺮ ﻣﻦ ﻣﺠﻤﻮﻋﺔ اﻟﻨﺘﯿﺠﺔ ‪ ResultSet‬ﺑﺄﺳﻢ ‪ rs‬ﻟﺤﻔﻆ اﻟﻨﺘﯿﺠﺔ ﻓﻲ ھﺬا اﻟﻤﺘﻐﯿﺮ‪.‬‬
‫‪ .2‬أﻧﺸﺊ ﻣﺜﯿﻞ ﻣﻦ ﺳﺎﺋﻖ اﻟﺮﺑﻂ ‪ Driver‬ﻣﻊ ‪ ،MySQL‬ﺑﺎﺳﺘﺨﺪام اﻟﻜﻮد اﻟﺒﺮﻣﺠﻲ‬
‫;)(‪Class.forName("com.mysql.jdbc.Driver").newInstance‬‬
‫‪ .3‬ﻣﻦ ﺧﻼل ﺳﻠﺴﻠﺔ ‪ ،String‬ﻋﺮف ﺛﻼﺛﺔ ﻣﺘﻐﯿﺮات‪ ،‬ﻣﺘﻐﯿﺮ ﯾﺤﻤﻞ ﻋﻨﻮان ﻣﻀﯿﻒ ﻗﺎﻋﺪة اﻟﺒﯿﺎﻧﺎت وﻣﻨﻔﺬھﺎ )‪ ،(3306‬وﻣﺘﻐﯿﺮ‬
‫آﺧﺮ ﯾﺤﻤﻞ اﺳﻢ اﻟﻤﺴﺘﺨﺪم ﻟﻘﺎﻋﺪة اﻟﺒﯿﺎﻧﺎت "‪ ،"root‬وﻣﺘﻐﯿﺮ ﺛﺎﻟﺚ ﯾﺤﻤﻞ ﻛﻠﻤﺔ اﻟﻤﺮور ﻟﻘﺎﻋﺪة اﻟﺒﯿﺎﻧﺎت ""‪ .‬طﺒﻌﺎ ﻧﺘﺮﻛﮭﺎ ﻓﺎرﻏﺔ‬
‫ھﻨﺎ ﻷﻧﻨﺎ ﻟﻢ ﻧﺤﺪد ﻛﻠﻤﺔ ﻣﺮور ﻣﺴﺒﻘﺎ ﻋﻠﻰ ‪.customers‬‬
‫‪ .4‬اﻵن ﯾﻤﻜﻦ ﺗﻨﻔﯿﺬ اﻟﺮﺑﻂ ﻣﻊ ﻗﺎﻋﺪة اﻟﺒﯿﺎﻧﺎت ﻣﻦ ﺧﻼل اﻟﻤﻨﮭﺞ ‪ getConnection‬اﻟﺘﺎﺑﻌﺔ ﻟﻠﺼﻨﻒ ‪ ،DriverManager‬ﺣﯿﺚ‬
‫ﺗﺄﺧﺬ ھﺬه اﻟﻄﺮﯾﻘﺔ ﺛﻼﺛﺔ ﻣﺘﻐﯿﺮات وھﻲ اﻟﺘﻲ ﺗﻢ ﺗﻌﺮﯾﻔﮭﺎ ﻓﻲ اﻟﻨﻘﻄﺔ اﻟﺴﺎﺑﻘﺔ )ﻧﻘﻄﺔ ‪.(3‬‬
‫‪ .5‬ﺛﻢ ﻧﻔﺬ ﺟﻤﻠﺔ اﺳﺘﻌﻼم ‪ SQL‬ﻣﻦ ﺧﻼل اﺳﺘﺪﻋﺎء اﻟﻤﻨﮭﺞ ‪ ،executeQuery‬وھﺬا اﻟﻤﻨﮭﺞ ﯾﺄﺧﺬ ﻣﺘﻐﯿﺮ ﻣﻦ ﻧﻮع ﺳﻠﺴﻠﺔ‪ ،‬ﯾﺤﻤﻞ‬
‫ﺟﻤﻠﺔ اﻻﺳﺘﻌﻼم ‪ ،Query‬اﻟﺘﻲ ﻧﺮﯾﺪ ﺗﻨﻔﯿﺬھﺎ ﻓﻲ ﻗﺎﻋﺪة اﻟﺒﯿﺎﻧﺎت‪ .‬ﻧﺘﯿﺠﺔ اﻟﺘﻨﻔﯿﺬ ﺗﻮﺿﻊ ﻓﻲ اﻟﻤﺘﻐﯿﺮ اﻟﺬي ﺗﻢ اﻧﺸﺎؤه ﻣﺴﺒﻘﺎ ﺑﺎﺳﻢ‬
‫ﻗﺲ ﻛﻨﻮع ﻣﻦ ﻣﺠﻤﻮﻋﺔ اﻟﻨﺘﯿﺠﺔ ‪.ResultSet‬‬
‫‪ .6‬ﻣﺴﺘﺨﺪﻣﺎ ﺟﻤﻠﺔ دوران‪ ،‬اطﺒﻊ ﺟﻤﯿﻊ اﻟﻤﺤﺘﻮﯾﺎت اﻟﺘﻲ ﺗﻢ ﺟﻠﺒﮭﺎ ﻣﻦ اﻟﻘﺎﻋﺪة‪.‬‬
‫‪ .7‬إﻏﻠﻖ ﺟﻤﯿﻊ ﻣﻨﺎﻓﺬ اﻟﺮﺑﻂ واﻟﺘﻌﺮﯾﻔﺎت اﻟﺘﻲ ﺗﺘﻌﻠﻖ ﺑﻘﺎﻋﺪة اﻟﺒﯿﺎﻧﺎت‪.‬‬
‫‪ .8‬ھﺬا اﻟﻤﺜﺎل ﯾﺴﺘﺨﺪم ﻣﻜﺘﺒﺔ ‪ ،sql‬ﻓﯿﻤﻜﻦ اﺳﺘﯿﺮاد ﻣﺎ ﻧﺤﺘﺎﺟﮫ ﻣﻦ اﻟﻤﻜﺘﺒﺔ ﻣﻦ ﺧﻼل ﺟﻤﻠﺔ واﺣﺪة ;*‪.import java.sql.‬‬

‫ﻓﻲ ھﺬا اﻟﺠﺰء‪ ،‬ﺳﺘﻌﻤﻞ ﻋﺰﯾﺰي اﻟﺪارس ﻣﻦ ﺧﻼل اﻟﺘﺪرﯾﺒﯿﻦ اﻟﺘﺎﻟﯿﯿﻦ ﻋﻠﻰ رﺑﻂ اﻟﺨﺎدم ‪ server‬ﻣﻊ ﻗﺎﻋﺪة ﺑﯿﺎﻧﺎت ﺑﺤﯿﺚ ﯾﻄﻠﺐ اﻟﺰﺑﻮن‬
‫‪ client‬ﺑﯿﺎﻧﺎت ﻣﻦ اﻟﺨﺎدم‪ ،‬ﻓﯿﻘﻮم اﻟﺨﺎدم ﺑﺈﻋﺎدة ﺗﻠﻚ اﻟﺒﯿﺎﻧﺎت ﻣﻦ ﻗﺎﻋﺪة ﺑﯿﺎﻧﺎت ﺗﻢ إﻧﺸﺎؤھﺎ ﻣﺴﺒﻘﺎ‪ .‬ﺳﺘﻄﺒﻖ ذﻟﻚ ﻓﻲ ‪ RMI‬وﻛﺬﻟﻚ‬
‫‪.CORBA‬‬
‫ﺗﺪرﯾﺐ ‪ :1‬ﻋﺪل ﻋﻠﻰ ﻛﻞ ﻣﻦ ﺑﺮﻧﺎﻣﺞ ﺧﺎدم ‪ RMI‬وﺑﺮﻧﺎﻣﺞ اﻟﺰﺑﻮن ‪ RMI‬ﺑﺤﯿﺚ ﯾﻄﻠﺐ اﻟﺰﺑﻮن‪ ،‬طﺎﻟﺐ ﺟﺎﻣﻌﻲ ﻓﺮﺿﺎ‪ ،‬ﺟﻠﺐ ﻋﻼﻣﺎﺗﮫ‬
‫ﻣﻦ اﻟﺨﺎدم‪ .‬اﻧﻈﺮ اﻟﺼﻮرة أدﻧﺎه‪.‬‬
‫ﺗﺪرﯾﺐ ‪ :2‬ﻋﺪل ﻋﻠﻰ ﻛﻞ ﻣﻦ ﺑﺮﻧﺎﻣﺞ ﺧﺎدم ‪ CORBA‬وﺑﺮﻧﺎﻣﺞ اﻟﺰﺑﻮن ‪ CORBA‬ﺑﺤﯿﺚ ﯾﻄﻠﺐ اﻟﺰﺑﻮن‪ ،‬طﺎﻟﺐ ﺟﺎﻣﻌﻲ ﻓﺮﺿﺎ‪ ،‬ﺟﻠﺐ‬
‫ﻋﻼﻣﺎﺗﮫ ﻣﻦ اﻟﺨﺎدم‪ .‬اﻧﻈﺮ اﻟﺼﻮرة أدﻧﺎه‪.‬‬
‫ﺗﺪرﯾﺐ ‪ :3‬ﻋﺪل ﻋﻠﻰ ﻛﻞ ﻣﻦ ﺑﺮﻧﺎﻣﺞ ﺧﺎدم ‪ XML-RPC‬وﺑﺮﻧﺎﻣﺞ زﺑﻮن ‪ XML-RPC‬ﻓﻲ اﻟﺘﺠﺮﺑﺔ اﻟﺴﺎﺑﻘﺔ ﺑﺤﯿﺚ ﯾﻄﻠﺐ اﻟﺰﺑﻮن‪،‬‬
‫طﺎﻟﺐ ﺟﺎﻣﻌﻲ ﻓﺮﺿﺎ‪ ،‬ﺟﻠﺐ ﻋﻼﻣﺎﺗﮫ ﻣﻦ ﺧﺎدم ﻋﻠﯿﮫ ﺑﯿﺎﻧﺎﺗﮫ اﻟﺸﺨﺼﯿﺔ‪ ،‬وھﺬا اﻟﺨﺎدم ﺑﺪوره ﯾﺠﻠﺐ اﻟﻌﻼﻣﺎت ﻣﻦ ﺧﺎدم آﺧﺮ ﺑﻨﻔﺲ ﺗﻘﻨﯿﺔ‬
‫اﻻﺗﺼﺎل اﻟﻤﺴﺘﺨﺪﻣﺔ‪ .‬اﻧﻈﺮ اﻟﺼﻮرة أدﻧﺎه‪ .‬ﯾﻤﻜﻨﻚ اﺳﺘﺨﺪام ﺗﻘﻨﯿﺔ اﻻﺗﺼﺎل ‪ RMI‬أو ﺗﻘﻨﯿﺔ ‪.CORBA‬‬

رﺮﻘﻤﻟ ﻲﻠﻤﻌﻟا ﻞﯿﻟﺪﻟا ﺔﻋزﻮﻤﻟا ﺔﻤﻈﻧﻷا 1479 Distributed Systems

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

رﺮﻘﻤﻟ ﻲﻠﻤﻌﻟا ﻞﯿﻟﺪﻟا ﺔﻋزﻮﻤﻟا ﺔﻤﻈﻧﻷا 1479 Distributed Systems

Uploaded by

Copyright:

Available Formats

‫اﻟﺪﻟﯿﻞ اﻟﻌﻤﻠﻲ ﻟﻤﻘﺮر‬

‫اﻷﻧﻈﻤﺔ اﻟﻤﻮزﻋﺔ ‪1479‬‬

‫إﻋﺪاد‪ :‬د‪ .‬م‪ .‬ﺳﺎﻣﺮ ﺣﺴﻨﻲ ﺟﺎﻟﻮدي‬

‫اﺳﺘﺪﻋﺎء اﻟﻄﺮق ﻋﻦ ﺑﻌﺪ‬

‫ﺛﺎﻟﺜﺎ‪ :‬ﺧﻄﻮات ﻋﻤﻞ اﻟﺘﺠﺮﺑﺔ‬

‫اﻟﻤﻠﻒ اﻷول ‪Hello.java‬‬

‫‪public interface Hello extends Remote‬‬

‫ﻟﻜﺘﺎﺑﺔ ﺑﺮﻧﺎﻣﺞ اﻟﺨﺎدم‪ ،‬ﻧﺘﺒﻊ اﻟﺨﻄﻮات اﻟﺘﺎﻟﯿﺔ‪:‬‬

public class Server implements Hello

‫ﻣﻌﻤﺎرﯾﺔ وﺳﯿﻂ طﻠﺐ اﻷھﺪاف اﻟﻤﺸﺘﺮﻛﺔ‬

‫‪Common Object Request Broker‬‬

‫ﺧﻄﻮات ﻋﻤﻞ اﻟﺘﺠﺮﺑﺔ‬

‫اﻟﻤﻠﻒ اﻷول ‪Hello.idl‬‬

‫ﯾﺤﻮي اﻟﺼﻨﻒ ‪ HelloServer‬ﻋﻠﻰ ﻣﻨﮭﺞ )(‪ ،main‬واﻟﺬي‪:‬‬

class HelloImpl extends HelloPOA

public class HelloServer

public class HelloClient

‫ﻣﻘﺪﻣﺔ ﻓﻲ ﻟﻐﺔ ﺑﺮﻣﺠﺔ اﻟﻮﯾﺐ ﺑﻲ اش ﺑﻲ‬

‫>‪<br> <u> This is HTML text </u> <br‬‬

‫راﺑﻌﺎ‪ :‬اﻟﻤﺘﻐﯿﺮات ‪Variables‬‬

‫ﺧﺎﻣﺴﺎ‪ :‬اﻟﺪوال ‪Functions‬‬

echo "7 + 8 = " . Addition (7, 8)."<br>";

‫ﺳﺎدﺳﺎ‪ :‬ﻣﺠﺎل اﻟﻤﺘﻐﯿﺮات ‪Scope of Variables‬‬

‫أﺳﺎﺳﯿﺎت ﻗﻮاﻋﺪ اﻟﺒﯿﺎﻧﺎت ﺑﺎﺳﺘﺨﺪام‬

‫ﺧﻄﻮات ﻋﻤﻞ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫ﻟﻠﺘﺄﻛﺪ ﻣﻦ أن اﻟﺒﯿﺎﻧﺎت اﻟﻤﺪﺧﻠﺔ ﺻﺤﯿﺤﺔ‪ ،‬اﺳﺘﻌﺮض ﻛﺎﻓﺔ ﻣﺤﺘﻮﯾﺎت اﻟﺠﺪول‪:‬‬

‫رﺑﻂ ﻗﻮاﻋﺪ اﻟﺒﯿﺎﻧﺎت ﺑﻠﻐﺔ ﺑﺮﻣﺠﺔ اﻟﻮﯾﺐ‬

‫ﺧﻄﻮات ﻋﻤﻞ اﻟﺠﺰء اﻷول‬

‫اﻟﻤﺜﺎل اﻷول ‪see1.php‬‬

‫ﺧﻄﻮات ﻋﻤﻞ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫اﻟﻤﺜﺎل اﻟﺜﺎﻧﻲ ‪see2.php‬‬

‫ﺧﻄﻮات ﻋﻤﻞ اﻟﺠﺰء اﻟﺜﺎﻟﺚ‬

see3.php ‫اﻟﻤﺜﺎل اﻟﺜﺎﻟﺚ‬

‫ﺧﻄﻮات ﻋﻤﻞ اﻟﺠﺰء اﻟﺮاﺑﻊ‬

‫اﻟﻤﺜﺎل اﻟﺮاﺑﻊ ‪see4.php‬‬

see5.php ‫اﻟﻤﺜﺎل اﻟﺨﺎﻣﺲ‬

‫اﺳﺘﺪﻋﺎء اﻹﺟﺮاء ﻋﻦ ﺑﻌﺪ ﺑﻠﻐﺔ ﺑﻲ اش ﺑﻲ‬

‫ﺧﻄﻮات ﻋﻤﻞ اﻟﺠﺰء اﻷول‬

‫اﻟﻤﻠﻒ اﻷول‪service.php :‬‬

‫ﺳﺆال ‪ :1‬أذﻛﺮ ﺧﻄﻮات إﻧﺸﺎء ﺧﺎدم ‪ ،XML-RPC‬ﻓﻲ ﻟﻐﺔ ‪PHP‬؟‬

‫اﻟﺒﺮﻧﺎﻣﺞ اﻟﺜﺎﻧﻲ ‪client.php‬‬

‫ﺳﺆال ‪ :2‬أذﻛﺮ ﺧﻄﻮات إﻧﺸﺎء زﺑﻮن ‪ ،XML-RPC‬ﻓﻲ ﻟﻐﺔ ‪PHP‬؟‬

‫ﺧﻄﻮات ﻋﻤﻞ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

‫رﺑﻂ ﺧﻮادم ‪ RMI‬و ‪ CORBA‬ﺑﻘﻮاﻋﺪ‬

‫ﺧﻄﻮات ﻋﻤﻞ اﻟﺠﺰء اﻷول‬

‫اﻟﻤﻠﻒ اﻷول‪Connector_mysql.java :‬‬

‫ﺧﻄﻮات ﻋﻤﻞ اﻟﺠﺰء اﻟﺜﺎﻧﻲ‬

You might also like