A fájlt az 1c webszolgáltatással fogadjuk el. Webszolgáltatások. Példa egy egyszerű WEB szolgáltatás létrehozására

1.2 Technológiák alkalmazhatósága kliens-szerver interakciós feladatokra.

2. Gyors kezdés. Hol kezdjem?

0. számú pont. Mindenekelőtt ki kell választania (dönteni) az integrációs technológiáról, és meg kell értenie a „lényegét” - vagyis hogyan fog működni.
Más szóval, két kérdésre kell válaszolnia:

• Melyik 1C adatbázis (vagy más program) fog működni kliensként és melyik szerverként;

• Melyik kliens-szerver interakciós technológia a legmegfelelőbb az Ön számára, és melyik technológia kerül alkalmazásra.

1. pont.
Tehát megértjük a kliens-szerver interakció „lényegét”. Az interakciós technológia meghatározása megtörtént. Most létre kell hozni egy „tesztterületet”, ahol a fejlesztés zajlik.

Ebben a cikkben két technológiát tárgyalunk példákon keresztül:

Munka a WEB szolgáltatási mechanizmussal.

Példák az 1C 8-ból és a PHP-ből származó munkákra;

Munka a http kérési mechanizmussal (REST webszolgáltatások).

Az 1C 8-ból és a PHP-ből származó munkák példáit is figyelembe kell venni;
A WEB fejlesztéssel kapcsolatos feladatokban hagyományosan elfogadott:

• Hozzon létre egy „tesztterületet” a fejlesztéshez és a hibakereséshez a programozó helyi WEB szerverén (localhost);
• A fejlesztés befejezése után az eredményeket át kell vinni a „harci” WEB szerverre.

A gyakorlatban (különösen, amikor elkezdi „megismerkedni” a WEB-szolgáltatások technológiájával), egy „tesztterület” létrehozásakor, valamint egy projekt „harci” szerverre való átvitelekor sok „rake” keletkezik.

Tehát, hogy ne „pazaroljunk” sok időt a beállításokkal való „harcra”. IIS(Internet Information Server) / a szerver elsajátítása apache, és a Windows engedélyek beállításához a következőket javaslom:

• (1) Hozzon létre egy "sokszöget" a helyi munkagépen. Operációs rendszer - Windows 7 (professzionális vagy maximális). Minden munkát rendszergazdai fiók alatt kell elvégezni.
• (2) Telepítse az 1C 8 adatbázist kliens-szerver módban (MS SQL szerver, javaslom a 2008 R2-t). Ha az 1C 8-at kliens-szerver módban használja, akkor nincs szükség további munkákra. az 1C adatbázishoz való hozzáférési jogok beállításai a WEB szerverről.
• (3) Telepítse IIS, ha hiányzik. Windows rendszerben rendszeresen „újratelepítheti”.

Az IIS-összetevők telepítési beállításainak jelölőnégyzetei alapértelmezés szerint beállíthatók.
A legfontosabb dolgok, amelyekre figyelni kell, a következő lehetőségek (ISAPI kiterjesztések - ez szükséges a szappankapcsolatok WEB-szolgáltatásokban való működéséhez, és CGI - ez szükséges a PHP működéséhez)

A telepítés befejezése után IIS Győződjön meg arról, hogy működik. Ehhez írja be a webböngésző címsorába:

(4) 1C adatbázis közzététele (csatlakoztatása) WEB szerveren.

És így, WEB szerver IIS telepítve és működőképes. Tegyük közzé az 1C adatbázisunkat, és ellenőrizzük, hogy a WEB kliensen keresztül is elérhető-e hozzá.

A felügyelt alkalmazás (vékony kliens) módban történő működést biztosító 1C adatbázist célszerű WEB szerveren közzétenni.

Az 1C adatbázis közzététele a következőképpen történik:
Konfigurátor módban meg kell hívnia a "Közzététel webszerveren" elemet.

b) Adja meg a közzétételi paramétereket:

Vagyis egy könyvtárban (mappában) wwwroot tiéd IIS külön mappát (könyvtárat) kell létrehoznia az 1C adatbázis közzétételéhez.

a wwwroot könyvtár automatikusan létrejön az IIS telepítésekor
Hozzunk létre és válasszunk ki egy ilyen mappát (wsBase10), adjuk meg a közzététel nevét (wsBase10-nek is fogjuk hívni).

Ha hirtelen üzenetet kap válaszul,

akkor ne félj.

Az 1C közzétételi mechanizmusa nagyon szeszélyes. Próbálja újra a „Közzététel” gombra kattintani.

És ha ennek eredményeként üzenetet kap,

vagyis minden működött.

Nagyon fontos megérteni, hogy amikor egy 1C adatbázist és WEB szolgáltatásait „harci” szerveren (például Windows 2008 R2) tesz közzé, akkor gyakran előfordulnak hibák, ha úgy dönt, hogy webszervert használ. IIS.

Tanács: ne telepítse "harci" szerverre IIS! Telepítés apache.

Ez megóvja Önt számos rendszerhibától. És a közzététel (újraközzététel - a konfiguráció módosításával) megtörténik apache zökkenőmentesen, anélkül, hogy a vrd fájlokkal és beállításokkal kellene trükközni IIS.

Ebben a cikkben nem foglalkozom az Apache telepítésének és konfigurálásával. Vannak más források is ebben a témában.

Az együttműködésre azonban apache az 1C adatbázissal (és webszolgáltatásokkal) számos nagyon fontos követelmény van, amelyeket tudnod kell (hozd ezt a rendszergazdának).

1. Telepítéskor apacheÜgyeljen arra, hogy engedélyezze az ISAPI-bővítmények támogatását.

2. Engedélyezze a cgi-bin támogatást, ha PHP-vel fog dolgozni;

3. Meg kell adnia egy speciális „felhasználót” az 1C adatbázisba...

Ennek a felhasználónak rendelkeznie kell az operációs rendszer hitelesítésével. És meg kell adnia azt a felhasználót, akinek a neve alatt elindul apache.

... Elkészültünk az apache-al, és térjünk vissza ismét a "poligonunkhoz".

Itt látjuk – indul az 1C. A WEB szerver az 1C-vel együtt működik.
4. PHP-szolgáltatás telepítése WINDOWS-hoz.

Szüksége lesz rá, ha feladatának részeként klienst (weboldalak az 1C eléréséhez) vagy szervert (forgatókönyvek az 1C-től érkező http kérések feldolgozásához) kell fejlesztenie PHP-ben.

5 Adjuk hozzá a wsClient10 könyvtárat az IIS-hez, amelyben a PHP szkriptjeink futni fognak.

Az általunk használt PHP szkriptek:

• Az ügyfélrész létrehozása az 1C WEB szolgáltatások fejlesztése során;
• A szerver rész fejlesztésére, REST webszolgáltatások (http kérések) fejlesztésénél.

6. Telepítsük a Notepap++ programot. Javaslom ennek a kompakt és kényelmes programnak a használatát PHP szkriptek szerkesztéséhez.

A Notepad++ telepítése után azonnal ellenőrizzük, hogy a PHP működik-e nekünk. Ehhez készítsünk egy egyszerű hello.php szkriptet. Helyezzük a wsClient könyvtárba, és futtassuk a szkriptet a böngészőből:

Minden oké. A PHP működik. A teszthely teljesen készen áll.

3. WEB szolgáltatás létrehozása, szappan kérések, XDTO és JSON. Példák 1C és PHP. Ebben a szakaszban készen kell lennie a „Polygon”-nak, és elkezdheti a WEB szolgáltatások fejlesztését.

- Hol kezdjem ennek a technológiának a tanulmányozását? Természetesen egy olyan klasszikus problémával, mint a „Helló szó”!

1. Egy egyszerű WEB szolgáltatás létrehozásának feladata. Nézzünk példákat az 1C-ben és a PHP-ben.

1.1. Adjuk hozzá az adatbázishoz (wsBase10) a "_Calculations by Tariffs" webszolgáltatást

Állítsuk a publikációs fájl nevét "calcOrder10.1cws"-re. Az URI névteret is meg kell adni. Elvileg bármilyen nevet megadhat.

1.2. Adjuk hozzá a „getHello” műveletet a „_Calculations by Tariffs” webszolgáltatáson belül.

A művelet lényege a legegyszerűbb - vegyen be három paramétert (karakterláncok, számok) bemenetként (az ügyféltől), és térjen vissza neki egy egységesítő karakterláncot (eredményként). A visszatérési érték típusa primitív lesz - string.

Nem jelöljük be a „Tranzakcióban” jelölőnégyzetet, mivel a művelet nem módosítja magában az 1C adatbázisban lévő adatokat.

Ha a műveletünk megváltoztatta az 1C adatbázis adatait, akkor ennek a négyzetnek a bejelölése lenne értelme.
A bejövő adatokat feldolgozó (és az eredményt visszaadó) metódus (függvény) neve „getHello”.

1.3. Adjunk hozzá bejövő paramétereket a "getHello" művelethez.

Az átvitel iránya "bemenet". Azaz átkerülnek a kliensről a szerverre.

1.4. Írjunk egy kezelőt a "getHello" művelethez a webszolgáltatás modulban
///////////////////

Függvény getHello(strParameter, floatParameter, integerParameter)
return strParaméter+karakterlánc(floatParameter+integerParameter)
EndFunction

////////

1.5. Ezen a ponton egy egyszerű WEB szolgáltatás létrehozásának munkája befejeződött. És most közzé kell tennie a "_Díjszabás szerinti számítások" WEB szolgáltatást.

Mielőtt webszolgáltatást teszünk közzé a tesztoldalon, minden felhasználót eltávolítunk információs bázisunk felhasználói listájáról. Vagyis „üresre” tesszük a felhasználók listáját.

- Miért csinálja ezt?

A teszthelyen csak a fejlesztő tud majd csatlakozni a WEB szolgáltatásokhoz, ezért nincs értelme a WEB szolgáltatáshoz való csatlakozáskor felhasználói hitelesítést biztosítani.

Vagyis szándékosan leegyszerűsítjük munkánkat a WEB-szolgáltatásokkal a tesztoldalon.

A kapcsolat létrehozásakor nem kell megadnunk a bejelentkezési nevet és a jelszót.
De egy „harci” szerveren természetesen hitelesítést kell biztosítania.
Ehhez (ahogy korábban említettük) külön kell létrehoznia egy felhasználót a „harci” adatbázisban, akinek a nevében maga a WEB-szerver elindul. Ezután, amikor kapcsolatot létesít a WEB szolgáltatással (szappankapcsolat), meg kell adnia a felhasználó bejelentkezési nevét és jelszavát is.

1.6. Tehát tegyük közzé a WEB szolgáltatást:

Vegye figyelembe, hogy nem kell bejelölnünk az „Operációs rendszer hitelesítés használata a webszerveren” jelölőnégyzetet. Ennek az az oka, hogy ez a mód csak a WEB-szerver számára biztosított IIS, és a „harci” szerveren működni fog Apache.

1.7. Hozzunk létre egy kliens részt és teszteljük a WEB szerver működését.

A) Először kezdeményezzünk ügyfélhívást az 1C-től.

Csináljuk egyszerűen. Bármely más 1C adatbázisban, amivel rendelkezik, külső feldolgozást hozunk létre. Ebben a feldolgozásban csatlakozunk a WEB szolgáltatáshoz, használjuk a „getHello” műveletet, átadjuk oda a paramétereket és választ kapunk a szervertől.
Az "1C" kódja valami ilyesmi lesz:

/////

&OnClient
Eljárás 10. lekérdezés végrehajtása (parancs)
// A kezelő tartalmának beillesztése.
LineResult = SERVER_ExecuteWSQuery10();
Figyelmeztetés(StringResult);
Az eljárás vége
&OnServerContext nélkül
SERVER_RunWSRequest10() függvény
// A teszthelyen hitelesítést nem végzünk!
Felhasználónév = undefined;
Jelszó = undefined;
http://localhost/wsBase10/ws/calcOrder10.1cws?wsdl ",Felhasználónév,Jelszó);
Proxy.User = Felhasználónév;
Proxy.Password = Undefined;
strResult = Proxy.getHello("Ivanov",100.35,20);
return strResult;
EndFunction ///////////////////////////////////////////////////////////////////////////////////////

Teszteljük a SERVER_ExecuteWSRequest10() függvény működését.

RENDBEN. Művek!
b) Most indítsunk ügyfélhívást a webszolgáltatáshoz PHP-ből.
A PHP script kódja valami ilyesmi lesz:

/
//////////////////////////////////////////////////////////////////////////////////

hibabejelentés(E_ERROR); // 1. Tiltsa le a szükségtelen üzeneteket
// 2. A SOAP gyorsítótárazásának letiltása. Ha ez nem történik meg,


// 3. Hozzon létre egy szappankapcsolatot
$client = new SoapClient("http://localhost/wsBase10/ws/calcOrder10.1cws?wsdl",
sor(
"login" => null, //bejelentkezés, nem hajtunk végre hitelesítést
"password" => null, //jelszó
"nyom" => igaz,
"features" => SOAP_USE_XSI_ARRAY_TYPE,
//"tömörítés" =>
);
// 4. Az átadott paraméterek tömbjének kitöltése
$params["strParametr"] = "teszt_Szappan10:";
$params["floatParameter"] = 10,34;
$params["integerParameter"] = 12;
// 5. Hajtsa végre a getHello műveletet
$eredmény = $kliens->getHello($params);
// 6. Jelenítse meg az eredményt a képernyőn
var_dump($eredmény);
?>

////
///

Hívjuk meg a szkriptet a böngészőből, és ellenőrizzük a működését:

Minden rendben, WEB oldalról 1C felhívása működik!

Összefoglalunk néhány eredményt:
Megoldódott az egyszerű WEB szolgáltatás problémája. És most elkezdheti összetettebb WEB-szolgáltatások létrehozását.

A bonyodalom pedig az lesz, hogy (eddig) csak primitív adattípusokkal operáltunk. Természetesen objektum (összesített) adattípusokat is továbbítanunk/fogadnunk kell majd.

2. WEB szolgáltatás létrehozásának feladata XDTO csomagok felhasználásával.

Mint korábban, nézzünk példákat az 1C-ben és a PHP-ben.

Tűzzük ki magunknak a következő feladatot: A WEB szolgáltatásnak nem karakterláncot, hanem objektumadatokat kell visszaadnia nekünk - egy „értéktáblázatot” (pontosabban, ez objektumok tömbje lesz!).

A különféle adatstruktúrák leírására (amelyekre a WEB-szerver fogadásakor/küldésekor lesz szükség) az 1C:8 platform mechanizmust biztosít az XDTO-csomagokhoz.

Azok. Először leírjuk az összes szükséges adattípust, majd jelezzük:

• Milyen XDTO-csomagokkal tud működni WEB szolgáltatásunk (megadhat egyet vagy csomaglistát);
• A művelet minden paraméterénél és az általa visszaadott eredménynél megadható, hogy milyen típusú adatok legyenek (az XDTO csomagból).

Hozzuk létre a GetTzTariffs_0 műveletet, amely tzTariffs típusú adatokat ad vissza.

Az ábra azt mutatja, hogy a tzTariffs korlátlan számú el objektumot tartalmaz. Valójában a tzTariffs az el típusú objektumok táblázata.

- Hogyan lehet látni?

• Ha a "maximum" paraméter "-1"-ként van megadva, akkor ezen objektumok száma nincs korlátozva (korlátlan számú sorral rendelkező táblázat);
• Ha nincs szükségünk táblázatra, csak egy struktúrára (egy sorra), akkor a maximális és minimális értéket „1”-el kell megadni.
• Az el objektum viszont egy olyan struktúra, amely egy objektumtípus attribútumot (eTariff) és egy primitív típusú attribútumot (cPrice, megjegyzés) tartalmaz.

A hierarchiában lefelé haladva látható, hogy a tarifatípus egy struktúra (maximális és minimális mennyiség = 1), amelynek egyik részlete tartalmazza a kindOfTariff típust.

Teljes: Az XDTO csomag lehetővé teszi az adattípusok hierarchiájának egyértelmű leírását, amelyeket a webszolgáltatással való interakció során tovább fog használni.

Tipp: A bonyolultság és a tervezési hibák elkerülése érdekében jobb, ha egy XDTO-csomagot használ egy webszolgáltatáshoz.
Menjünk tovább... Utána:

• Az XTDO csomag elkészült;
• Minden adattípus leírásra kerül;
• A WEB szolgáltatáshoz ennek a csomagnak a használata fel van tüntetve;
• A paraméterekhez és a műveleti eredményekhez kiválasztják a megfelelő típusokat (az XDTO csomagból)

Példánkban a GetTzTariffs_0 műveletnek Tariffs objektumokat tartalmazó karakterláncok tömbjét kell visszaadnia.

////////////////

GetTzTariffs_0() függvény
// A kezelő tartalmának beillesztése.
Visszatérés GetTZTariffs_0();
EndFunction

GetTZTariffs_0() függvény


// A műszaki adatok kitöltése
// 1. sor

kindOfTariff.active = false;


tarifa.fajta = kindOfTariff;

elementTZ.eTariff = tarifa;
elemTZ.cÁr = 100;

//
// 2. sor
kindOfTariff = FactoryXDTO.Create(kindOfTariffType);

tarifa = FactoryXDTO.Create(tariffType);
tarifa.begdate = AktuálisDátum();
tarifa.fajta = kindOfTariff;
elementTZ = FactoryXDTO.Create(elemTZType);
elementTZ.eTariff = tarifa;
elemTZ.cÁr = 200;
// Adja hozzá a 2. sort a táblázathoz
tzTariffs.el.Add(elementTZ);
Return tzTariffs;
EndFunction

//////////
Ezután adunk egy példát a "GetTzTariffs_0" művelet kliens oldalról történő meghívására, 1C-ből.

&OnClient
Eljárás 20. lekérdezés végrehajtása (parancs)
// A kezelő tartalmának beillesztése.
Figyelmeztetés(SERVER_ExecuteWSQuery20());
Az eljárás vége
&OnServerContext nélkül
SERVER_ExecuteWSRequest20() függvény
Definíciók = new WSDDefinitions("http://localhost/wsBase10/ws/calcOrder10.1cws?wsdl");
Proxy = new WSProxy(Definitions,"www.URI.com","_Calculations By Tariffs","_Calculations By TariffsSoap");
XDTResult = Proxy.GetTzTariffs_0();
// Lépjünk be a nulla indexnél lévő sort, majd az eTariff attribútumhoz, majd a beágyazott attribútum típushoz, majd a beágyazott attribútum nevéhez.
EndFunction

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Egy hasonló hívás a PHP-től és az XDTO eredmények feldolgozása a következő lenne:
////////////////////////////////////////////////////////////////////////////////////

// a webszolgáltatás funkciói nem fognak megfelelően működni.
ini_set("soap.wsdl_cache_enabled", "0");
$client = new SoapClient("http://localhost/wsBase10/ws/calcOrder10.1cws?wsdl ");
$eredmény = $kliens->GetTzTariffs_0();
$mResult = $eredmény->return->el;
// mResult – objektumok tömbje. Menjünk végig a tömb elemein, és jelenítsük meg az eredményeket a képernyőn
for ($i=0; $i {
visszhang"
";
$eTariff = iconv("utf-8","cp1251",$mResult[$i]->eTariff->fullName);
var_dump($eTariff);
$cPrice = $mEredmény[$i]->cÁr;
var_dump($cPrice);
$cComment = $mResult[$i]->cComment;
var_dump($cComment);
visszhang"
";
}
?>

//////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////

Most Bonyolítsuk még jobban a feladatot. Vigyük át ugyanazt az objektum adattípust a kliensről a WEB szolgáltatásba (paraméterként). Legyen tzKind.
Ehhez először leírjuk ezt a típust a dataTariffs csomagban, majd hozzáadjuk a GetTzTariffs_1 műveletet.

Jelöljük meg a tzKind paraméter típusát.

Példa arra, hogyan működik egy WEB szolgáltatás egy bejövő XDTO paraméterrel:
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Függvény GetTZTariffs_1(tzKind)
tzTariffsType = FactoryXDTO.Type(" ", "tzTariffs");
tzTariffs = FactoryXDTO.Create(tzTariffsType);
elementTZType = FactoryXDTO.Type(" ", "elementTZ");
tarifaTípus = FactoryXDTO.Type(" ", "tarifa");
kindOfTariffType = FactoryXDTO.Type(" ", "kindOfTariff");
// A műszaki adatok kitöltése
// 1. sor
kindOfTariff = FactoryXDTO.Create(kindOfTariffType);
kindOfTariff.name = "Szállítás";
kindOfTariff.active = false;
tarifa = FactoryXDTO.Create(tariffType);
tariff.fullName = "1. tarifa";
tarifa.begdate = AktuálisDátum();
tarifa.fajta = kindOfTariff;
elementTZ = FactoryXDTO.Create(elemTZType);
elementTZ.eTariff = tarifa;
elemTZ.cÁr = 100;
elementTZ.comment = "Az 1. tarifa leírása";
// Adja hozzá az 1. sort a táblázathoz
tzTariffs.el.Add(elementTZ);
// 2. sor
kindOfTariff = FactoryXDTO.Create(kindOfTariffType);
kindOfTariff.name = "Kézbesítés";
kindOfTariff.active = igaz;
tarifa = FactoryXDTO.Create(tariffType);
tariff.fullName = "2. tarifa";
tarifa.begdate = AktuálisDátum();
tarifa.fajta = kindOfTariff;
elementTZ = FactoryXDTO.Create(elemTZType);
elementTZ.eTariff = tarifa;
elemTZ.cÁr = 200;
elementTZ.comment = "A 2. tarifa leírása";
// Adjon hozzá egy 3. sort a táblázathoz (töltse ki a bejövő adatokkal)
tzTariffs.el.Add(elementTZ);
// 3. sor
kindOfTariff = FactoryXDTO.Create(kindOfTariffType);
kindOfTariff.name = tzKind.el.eKind.name;
kindOfTariff.active = tzKind.el.eKind.active;
tarifa = FactoryXDTO.Create(tariffType);
tariff.fullName = "3. tarifa";
tarifa.begdate = AktuálisDátum();
tarifa.fajta = kindOfTariff;
elementTZ = FactoryXDTO.Create(elemTZType);
elementTZ.eTariff = tarifa;
elemTZ.cÁr = 300;
elementTZ.comment = "A 3. tarifa leírása";
// 3. sor hozzáadása a táblázathoz
tzTariffs.el.Add(elementTZ);
Return tzTariffs;
EndFunction

//////////////////////////////////////////////////////////////////////////////////
1C kliens oldalról tzKind típusú adatokat kell készítenünk és át kell vinnünk a WEB szolgáltatásba.

Íme egy példa egy ilyen hívásra:
/////////////////////////////////////////////////////////////////////////////////

&OnClient
Eljárás 30. lekérdezés végrehajtása (parancs)
// A kezelő tartalmának beillesztése.
Figyelmeztetés(SERVER_ExecuteWSQuery30());
Az eljárás vége
&OnServerContext nélkül
SERVER_ExecuteWSRequest30() függvény
Definíciók = new WSDDefinitions("http://localhost/wsBase10/ws/calcOrder10.1cws?wsdl");
Proxy = new WSProxy(Definitions,"www.URI.com","_Calculations By Tariffs","_Calculations By TariffsSoap");
// Hozzon létre egy táblázatot a WS-nek átadott paraméterekről
tzKindType = Proxy.FactoryXDTO.Type(" ", "tzKind");
tzKind = Proxy.FactoryXDTO.Create(tzKindType);
kindOfTariffType = Proxy.FactoryXDTO.Type(" ", "kindOfTariff");
kindOfTariff = Proxy.XDTO Factory.Create(kindOfTariffType);
kindOfTariff.name = "Teszt tarifatípus";
kindOfTariff.active = false;
elementKindType = Proxy.FactoryXDTO.Type(" ", "elementKind");
elementKind = Proxy.XDTO Factory.Create(elemKindType);
elementKind.eKind = kindOfTariff;
elemKind.mennyiség = 10;
// Adjon hozzá egy sort a táblázathoz
tzKind.el.Add(elemKind);
XDTOResult = Proxy.GetTzTzriffs_1(tzKind);
Példa Tarifatípus Eredmény_neve = XDTOReredmény.el.eTariff.fajta.név;
Vissza Példa Eredmény_tarifatípus neve;
EndFunction

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Szeretném felhívni a figyelmet a tervezésre: Proxy.FactoryXDTO.Type("...

Azaz, amikor a kliensen XDTO csomagobjektumot hozunk létre, nem a saját XDTO!-gyárunkhoz kell hozzáférnünk, hanem egy Proxy-n keresztül. Vagyis az XDTO szervergyárba.

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Itt az ideje feltenni a kérdést:van-e alternatívája az XDTO objektumoknak ?

Lehet-e egyáltalán „nem kommunikálni” az XDTO gyárral, más módon továbbítani/fogni WEB szolgáltatásból.. (főleg ha nem 1C a kliens, hanem pl WEB oldal, alkalmazás Androidon, iOS-en stb.).

A válasz- igen tudsz!
Például használhatja a karakterláncot paramétertípusként. És adatstruktúrákat „pakolj” (sorosíts) bele.

Ezt a technológiát a WEB-programozásban már régóta fejlesztették, és JSON-nak hívják.
Az is nagy segítség, hogy PHP-ben bármilyen struktúra/tömb karakterlánc bepakolása/kibontása egy lépésben történik!
Példa PHP-ben az objektumok JSON-ba történő csomagolására/kibontására, továbbítására/vételére egy WEB-szolgáltatásba:

///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////

// szerializálja az mDelivery tömböt egy karakterláncba, és helyezze a szállítási paraméterbe
// * Először is írjuk le a szállítási struktúrát
osztály szállítás (
var $id;
var $ellenőrizve;
var $érték;
}
// A szerkezet kitöltése néhány adattal
$sDelivery = új szállítás;
$sDelivery->id = "000000005";
$sDelivery->checked = IGAZ;
$sDelivery->value = 0;
// Adja hozzá az mDelivery objektumok tömbjéhez
$mDelivery = $sDelivery;
// Konvertálja az mDelivery tömböt JSON-karakterláncsá, és helyezze az eredményt a szállítási paraméterbe
$params["szállítás"] = json_encode($mDelivery);
// Hívja meg az ExitCalcOrder műveletet a WEB szolgáltatáson, és adjon át neki egy paramétert (karakterlánc - szállítás);
$eredmény = $kliens->ExitCalcOrder($params);
// Az ExitCalcOrder művelet eredményének beolvasása a jsCalcResult változóba (karakterlánc)
$jsCalcResult = $eredmény->return;
// Végezze el a fordított átalakítást: a jsCalcResult karakterláncból egy objektummá (objektumtömb, típusegyezik) arrCalcResult
$arrCalcResult = json_decode($jsCalcResult);
// Információk megjelenítése a képernyőn az arrCalcResult objektumról
var_dump($arrCalcResult);

////////////////////////////////////////////////////////////////////////////////

De hogyan lehet JSON-konverziókat végrehajtani 1C-ben?
Az 1C 8 platform nem támogatja a JSON szabványt, de ez nem probléma.
A JSON konverziós/kivonási feldolgozás létezik, elérhető és kiválóan működik
// Copyright © 2010-2012 Alexander Pereverzev
// 1C:JSON . JavaScript Object Notation elemző és szerializáló.

Így csak helyezze el ezt a feldolgozást a konfigurációjában, és könnyen végrehajthat előre és fordított JSON-konverziókat:
Példa sorozatosításra 1C objektum a JSON karakterlánchoz:

///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////

CargoData = új szerkezet;
CargoData.Insert("kód",Rakománykód);
CargoData.Insert("szám",Rakományszám);
CargoData.Insert("terv", Mennyiségi terv);
CargoData.Insert("karakter",Rakománykarakter);
CargoData.Insert("packing", Packaging);
CargoData.Insert("károsodás",Csomagolás sérülése);
CargoData.Insert("kötet",kötet);
CargoData.Insert("súly",súly);
CargoData.Insert("állapot",állapot);
jsResult = JSON.WriteJSON(LoadData); //Az eredmény konvertálása JSON-ba
return jsResult;

Példa kivonata objektum az 1C-ben JSON-karakterláncból:
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// 1. Állítsa vissza az objektumokat JSON-ból
JSON = Process.JSON.Create();
mdelivery = JSON.ReadJSON(szállítás);
// ennek eredményeként az mdelivery egy tömb. Tömb elem - egyezés.
// Ez például az mdelivery.["id"] a következőt fogja tartalmazni: "000000005"

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Befejezésül egy példát mutatok be az 1C webszolgáltatás PHP-ből való meghívására, amely megkapja a visszaadott JSON-struktúrát a PHP objektumokká való fordított átalakításáról.

Figyeljünk az átalakulásokra iconv("cp1251","utf-8","
és iconv("utf-8","cp1251", amely szükséges lesz (a PHP - 1 C-vel való interakció során) a cirill karakterláncok cp 1251 kódolásról utf -8-ra és vissza konvertálásához.

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

hibabejelentés(E_ERROR); // Üzenetek letiltása
// A SOAP gyorsítótárazásának letiltása. Ha ez nem történik meg,
// a webszolgáltatás funkciói nem fognak megfelelően működni.
ini_set("soap.wsdl_cache_enabled", "0");
$kliens = new SoapClient("http://localhost/wsBase10/ws/wsQuery.1cws?wsdl");
$params["fname"] = iconv("cp1251","utf-8","dataFreight");
$params["param1"] = iconv("cp1251","utf-8",$_GET["kód"]);
$params["param2"] = iconv("cp1251","utf-8",$_GET["szám"]);
$eredmény = $kliens->executeQuery($params);
$jsResult = $eredmény->return;
$dataFreight = json_decode($jsResult);
$statusFreight = $dataFreight->codeNm;
$számFreight = iconv("utf-8","cp1251",$dataFreight->nameRus);
?>

///////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////

A valószínű forgatókönyv a következő: egy távoli felhasználó valamelyik programjából (pl. WEB oldalról, mobilalkalmazásból stb.) felhívja a WEB szolgáltatását és... nem kap eredményt.. Vagy megkapja, de valami nem stimmel.

Kérdés: - Hogyan lehet tájékozódni az ilyen hibákról és hibakeresni a WEB szolgáltatást?
Azt javaslom, hogy használjon naplót a hibák figyelésére (és a bejövő paraméterek összegyűjtésére, „mi vezette hibához a webszolgáltatást”).

Azok. azon a helyen, ahol logikai hibák előfordulhatnak, programozottan mentse el a bejövő paraméterekkel kapcsolatos információkat a regisztrációs naplóba (LogRecord)

Ha „futásidejű hibákkal küszködik”, elfoghatja azokat (egy kísérlet kivétel), és „pontról pontra” naplózhatja a teljes helyzetet.

Ennek eredményeként a napló segítségével információkat láthat a hibákról, reprodukálhatja az esemény paramétereit, és interaktív módban, a hibakeresőben „legyőzheti” azt.

Összefoglaljuk: Példák az 1C és a PHP webszolgáltatásaival való munkavégzésre. Az objektum adatszerkezetek kliens és szerver közötti átviteléhez két technológiát használtunk:

• (1) XDTO-csomagok
• (2) JSON objektumok.

4. Alternatív - REST webszolgáltatások (http kérések). Példák a megvalósításra 1C-ben és PHP-ben.
Az előző részben részletesen megvizsgáltuk a WEB szolgáltatások technológiáját. Ebben a részben egy alternatív technológiát, az ún. REST webszolgáltatások.

Felmerül egy jogos kérdés: - Miért?

A WEB szolgáltatások teljes mértékben működőképesek, és lehetővé teszik bármilyen összetett probléma megoldását.

A „miért” megértéséhez fogalmazzuk meg az alapvető különbségeket e technológiák között.

A WEB szolgáltatások technológiája 2 ponton alapul:

• (1) SOAP kapcsolat van használatban. Más szóval, SOAP kérés történik.

Definíciók = new WSDdefinitions("http://localhost/wsBase10/ws/calcOrder10.1cws?wsdl",Felhasználónév,Jelszó);
Proxy = new WSProxy(Definitions,"www.URI.com","_Calculations By Tariffs","_Calculations By TariffsSoap");

/////////////////////////////////////////////////////////////////////////////////////////

PHP-ben ez így van:

/////////////////////////////////////////////////////////////////////////////////////////

$client = new SoapClient("http://localhost/wsBase10/ws/calcOrder10.1cws?wsdl",
sor(
"login" => bejelentkezés, //bejelentkezés,
"password" => jelszó, //jelszó
"nyom" => igaz,
"features" => SOAP_USE_XSI_ARRAY_TYPE,
//"tömörítés" => SOAP_COMPRESSION_ACCEPT | SOAP_COMPRESSION_GZIP | 5
);

/////////////////////////////////////////////////////////////////////////////////////////

• (2) A szappankapcsolat szerver módban történő feldolgozásához az 1C 8 platform speciális metaadat-objektum WEB-szolgáltatásokat biztosít.

Ezenkívül, ha az Ön feladatában az „1C”-nek szerverként kell működnie, akkor nincs alternatívája az 1C WEB szolgáltatástechnológiának.

- Mikor lehetséges alternatíva?

• Először is, amikor az 1C csak ügyfélként működik;
• Másodszor, amikor a kiszolgáló, amellyel dolgoznia kell (például egy webhely vagy valamilyen WEB-alkalmazás), a tervek szerint nem támogatja a SOAP-kapcsolatot.

Nagyon népszerű lehetőség - http kapcsolat.

Web alapú rendszerekben (PHP, Android, iOS) egyszerűbb a http kérésekkel dolgozni, mint a SOAP kérésekkel. És a nem túl bonyolult projektekhez a http kérés technológia meglehetősen megfelelő.

A klasszikus megoldás (http kérés módszerrel) az 1C adatbázis és a WEB oldal integrálása. Például a termékválasztékra és az árakra vonatkozó információk továbbításra kerülnek az oldalra, és az elfogadott rendelésekről szóló információk visszaküldésre kerülnek az oldalról.

Jellemző, hogy a tipikus 1C konfigurációkban a webhelyekkel való integráció http-kérésekkel valósul meg.
Tehát nézzük a technológiát http kérések Például interakció az 1C (kliens, 1C 8) és a WEB oldal (PHP, szerver) között.

1. Kapcsolat létrehozása és módszerek a paraméterek átadására egy http kérésben
Példa a szerverrel való kapcsolat létrehozására az 1C oldalról:
/////////////////////////////////////////////////////////////////////////////

védett = hamis;
HTTPConnect = new HTTPConnect("localhost/wsClient10/json/testHTTPQuery11.php", Védett);

////////////////////////////////////////////////////////////////////////////
Mint tudják, két módszer létezik a paraméterek átvitelére az ügyfélről a szerverre a http protokollon keresztül:

(1) „get” módszer;

A paraméterek (például a név és a jelszó) közvetlenül a szerverhívás URL-jében vannak megadva.

Vagyis a szkript interaktív hívása (közvetlenül egy webböngészőből) így néz ki:

Az 1C:8-ban a szerver programozott hívásához (és a Get metódusok paramétereinek átadásához) a „Get” metódus biztosított.

Példa:
védett = hamis;
HTTPConnect = new HTTPConnect("localhost", Biztonságos);
HTTPConnect.Get("wsClient10/json/testHTTPQuery11.php?nameVasya&password=123",OutputFileName);

ahol OutputFileName: Annak a fájlnak a neve, amelybe a szerverről visszaadott adatok kerülnek.
Vagyis a kérés feldolgozása eredményeként a szerver visszaküldi az eredményt az 1C-nek, majd (automatikusan) létrejön egy fájl, amely tartalmazza az eredményt.

Ennek megfelelően ezt követően az „1C”-ben (programozottan) el kell olvasni ezt a fájlt, és ki kell bontani a kapott eredményt. Ez minden.

(2) „posta” módszer;

Ennél az opciónál a paraméterek nem az URL-be kerülnek, hanem külön-külön, a http kapcsolat törzsében kerülnek továbbításra.

Nyilvánvaló, hogy a módszer fő korlátja kap a továbbított adatok mennyisége és tartalma. Vagyis a segítséggel kap Csak karakterek adhatók át, és az URL-karakterlánc hossza korlátozott.

Módszer hozzászólás Különféle tartalmú adatokat továbbíthat, pl. és tetszőleges fájlok.
És így, hozzászólás az integrációs feladatoknál funkcionálisabb, és továbbra is dolgozunk vele.

Az 1C és a WEB oldal közötti adatok fogadásához/továbbításához szöveges fájlokat használunk.
Az adatokat pedig a számunkra már jól ismert JSON technológiával „csomagoljuk/kivonjuk” a fájlokból! Ez gyakorlatilag megkímél minket attól, hogy „elemzzük” a fájlt az 1C oldalon és a PHP oldalon.

A szerver meghívásához és a paraméterek átviteléhez a "post" módszerrel az 1C:8 a következő módszert kínálja: SendForProcessing

És így, mondjunk egy példát, amelyben az oldalon 1C minden feldolgozási lépést végrehajtanak http kérés:

Először is írjuk le az akciótervet (nagyítva):

És most a szoftver megvalósítása 1C:8-ban

////////////////////

// 1. Töltse ki a továbbított adatok szerkezetét!
postDataToPHP = új struktúra;
postDataToPHP.Insert("param1","ivanon");
postDataToPHP.Insert("param2","ivan");
postDataToPHP.Insert("param3","ivanovics");

// 2. Konvertálja az adatokat JSON-karakterláncsá
JSON = Process.JSON.Create();
jsPostDataToPHP = JSON.WriteJSON(postDataToPHP);

// 3. Hozzon létre egy ideiglenes kimenő üzenetet (a POST módszerrel továbbítva a szerverre)
// fájl, tegyen bele egy JSON karakterláncot.
tFile = új szövegdokumentum;
stringData = jsPostDataToPHP;
tFile.AddLine(stringData);

// 4. Kérje le az ideiglenes kimenő fájl nevét. A kimenő adatokat JSON-karakterlánc formájában fogja tartalmazni
OutgoingFileName = GetTemporaryFileName(.txt");
tFile.Write(OutgoingFileName,TextEncoding.UTF);

// 5. Kérje le az ideiglenes bemeneti fájl nevét. JSON karakterláncot kap: PHP szerver választ
InputFileName = GetTemporaryFileName(.txt");

// 6. Hozzon létre HTTP kapcsolatot a szerverrel
védett = hamis;
HTTPConnect = new HTTPConnect("localhost/wsClient10/json/testHTTPQuery10.php", Védett);

// 7. Végezzünk el egy HTTP kérést. Vigyük át a kimenő fájlt a szerverre (a fájl JSON objektumot, azaz kimenő paramétereket tartalmaz)

HTTPConnect.SendForProcessing(OutgoingFileName,"/json/",IncomingFileName);

// És választ kapunk a szervertől (bejövő fájl). A fájl //JSON objektumot tartalmaz (azaz a szerverről visszaadott adatokat)

// 8. Bontsa ki a szerverről kapott adatokat a bejövő fájlból
ResponseFile = új TextDocument;
ResponseFile.Read(InputFileName,TextEncoding.UTF);
json_Data = ResponseFile.GetString(1);
mData = JSON.ReadJSON(json_Data);

// 9. A fogadott adatok megjelenítése a felhasználó számára
Jelentés(mData["v1"]);
Jelentés(mData["v2"]);

// 10. Törölje a használt (már nem szükséges) ideiglenes fájlokat.
DeleteFiles(OutgoingFileName);
DeleteFiles(InputFileName);

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

És végül, példa PHP-ben egy kérés feldolgozására a szerver oldalon:

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// 1. Karakterlánc-adatok beszerzése a bejövő fájlból
$json_filedata = file_get_contents("php://input");
// 2. Vágja le az összes felesleges karaktert (2 szervizkarakter kerül hozzáadásra), // ami zavarja a JSON-ból való átalakítást
$jsData = trim(ltrim($json_filedata));
$dlinaStr = strlen($jsData);
$_jsData = "";
$i=1;
míg ($i<$dlinaStr) {
ha ($i>2) (
$_jsData = $_jsData.substr($jsData, $i, 1);
}
$i++;
}
// 3. Adatok konvertálása JSON-ból objektummá (struktúrává)
$mData = json_decode($_jsData);
// 4. Készítsünk egy másik struktúrát, amit kitöltünk adatokkal és // visszatérünk az 1C-hez
osztály returnData(
var $v1;
var $v2;
}
$sReturnData = új returnData;
$sReturnData->v1 = $mData->param1;
$sReturnData->v2 = $mData->param2;
// 5. Alakítsa át a szerkezeti adatokat JSON-karakterláncsá
$json_returnData = json_encode($sReturnData);
// 6. Állítsa vissza az adatokat 1C-be (a kimeneti adatok át lesznek irányítva egy fájlba, amely visszakerül az 1C-be)
echo $json_returnData;
?>

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Ez minden. Kompakt és funkcionális!

5. Igény szerinti feladatok (projektesetek)

Befejezésül azokat idézem, amelyekre de facto most a legnagyobb a kereslet az ügyfelek körében, és amelyeket WEB szolgáltatások és http kérések segítségével oldanak meg.