Ang engine ng panuntunan ng JAVA batay sa Rete algorithm

Java Rule Engine Based Rete Algorithm



May-akda: Zhang Yuan Xia Qingguo (College of Computer, Northwestern Polytechnical University, Xi'an 710072)
Mula sa: Agham, Teknolohiya at Engineering, Vol. 6 Bilang 11 Hunyo 2006

Buod



Kung ang mga patakaran ay maaaring makuha sa aplikasyon ng software, ang entidad ng software ay maaaring gawing mas may kakayahang umangkop, at ginawang posible ito ng engine ng mga patakaran. Ang algorithm na Rete ay unti-unting nabago sa isa sa pinakamahalagang pangunahing algorithm. Una, ang prinsipyo ng engine ng panuntunan at ang JAVA API nito ay binibigyang diin. Pangalawa, ang Rete algorithm ay inilarawan. Sa wakas, sina Jess at ang bukas na proyektong pinagmulan ng Drools ay maikling ipinakilala.



Mahahalagang salita



Rule Engine Rete Algorithm Java API Doorls J2EE
Numero ng Pag-uuri ng Library ng Chinese na TP311.11 Code ng Pagkakakilanlan ng Dokumento B

Sa pagpapatupad ng JAVA, karaniwang may tatlong mga layer, ang bawat layer na naaayon sa isang mahusay na balangkas para sa mga developer na mag-focus sa pagbuo ng pinaka-kritikal, kabilang ang framework ng layer ng pagtatanghal (Struts, JSF, atbp.), Ang framework ng layer ng pagtitiyaga (JDO at Mga Entity Beans, atbp.) At isang nakabalangkas na balangkas (tulad ng EJB). Sa mga balangkas na ito, walang balangkas na lohikal na lohika. Ipinapakita ng Larawan 1 ang kasalukuyang estado [1].

Larawan 1 Framework para sa mga aplikasyon ng Java



Kailangan ang engine ng panuntunan dito. Nakatuon ang artikulong ito sa alituntunin ng engine ng mga patakaran at ginamit ang Rete algorithm, at inilalarawan ang dalawang pangunahing mga balangkas.

Mayroong kalakaran sa pagpapaunlad ng negosyo sa antas ng enterprise, iyon ay, madalas na nagbabago ang mga patakaran sa negosyo, at karamihan sa mga kadahilanan ng mga pagbabago ay nagmula sa mga hindi nag-develop, at kahit sa mga developer, maraming mga kumplikadong patakaran ang mahirap makuha ang mga algorithm at abstract data mga modelo. Bukod dito, ang mga patakarang ito sa negosyo ay madalas na hindi maaaring magamit bilang matatag na mga kinakailangan, iyon ay, maaari pa rin silang magbago pagkatapos ng disenyo at pag-coding. At ang mga patakaran sa negosyo ay madalas na naka-embed sa code ng system, na nagdudulot ng malalaking paghihirap sa pagpapanatili at pag-update ng system, at mas imposible para sa mga hindi nag-develop na pamahalaan. Nalulutas ng rules engine ang problemang ito.

1 tuntunin engine

1.1 Mga panuntunan sa negosyo

Ang isang patakaran sa negosyo ay binubuo ng isang hanay ng mga kundisyon at pagpapatakbo na isinagawa sa ilalim ng mga kundisyong ito na kumakatawan sa isang piraso ng lohika sa negosyo para sa isang application na panuntunan sa negosyo. Ang mga patakaran sa negosyo ay karaniwang dapat na binuo at binago ng mga analista ng negosyo at mga tagapamahala ng patakaran, ngunit ang ilang mga kumplikadong patakaran sa negosyo ay maaari ding ipasadya ng mga tekniko na gumagamit ng mga teknikal na wika o script na nakatuon sa object.

Ang teoretikal na batayan ng mga patakaran sa negosyo ay upang magtakda ng isa o higit pang mga kundisyon na nagpapalitaw ng isa o higit pang mga operasyon [3] kapag natutugunan ang mga kundisyong ito.

1.2 Ang istraktura ng engine ng mga panuntunan

Ang arkitektura ng rules engine ay ipinapakita sa Larawan 2:

Larawan 2 Mga Panuntunan sa Negosyo sa Arkitektura ng Engine

Ang mga hakbang sa pangangatuwiran ng engine ng mga panuntunan ay ang mga sumusunod:

a. Ipasok ang paunang data sa memorya ng pagtatrabaho
b. Paghambingin ang mga patakaran at data sa batayan ng panuntunan gamit ang pagtutugma ng pattern
c. Kung mayroong isang salungatan sa mga patakaran sa pagpapatupad, ibig sabihin maraming mga patakaran ang naisaaktibo nang sabay, ang magkakasalungat na mga patakaran ay inilalagay sa itinakdang pagtatalo
d. Malutas ang mga salungatan, ilagay ang mga aktibong panuntunan sa agenda ayon sa pagkakasunud-sunod
e. Isagawa ang mga patakaran

Ulitin ang mga hakbang b hanggang sa e hanggang sa nakumpleto mo ang lahat ng mga patakaran sa agenda. Kailangang malutas ng anumang engine ng panuntunan ang problema sa kahusayan ng mekanismo ng pangangatuwiran ng panuntunan at pagtutugma ng kundisyon ng kundisyon. Kapag nag-ehersisyo ang makina, ang halimbawa ng pagpapatupad ng panuntunan ay isinasagawa isa-isa ayon sa priyoridad na pagkakasunud-sunod sa pila ng pagpapatupad ng patakaran. Dahil ang bahagi ng pagpapatupad ng panuntunan ay maaaring baguhin ang object ng data ng lugar ng trabaho, ang ilang mga kaso ng pagpapatupad ng panuntunan sa pila ay maaaring mabigo dahil sa pagbabago ng kundisyon. , dapat na bawiin mula sa pila maaari rin itong buhayin ang mga patakaran na hindi nakamit ang mga kundisyon, at bumuo ng isang bagong halimbawa ng pagpapatupad ng panuntunan sa pila. Samakatuwid, nabuo ang isang 'pabago-bagong' panuntunan sa pagpapatupad ng panuntunan, na bumubuo ng isang mekanismo ng pangangatuwiran na batay sa panuntunan. Ang tugon na 'nakakadena' ng naturang mga panuntunan ay buong hinihimok ng data sa workspace.

2 Network algorithm

2.1 Panimula

Karamihan sa mga patakaran ng algorithm ng produkto ng engine ay karaniwang nagmula mula sa Rete algorithm ni Dr. Charles Forgy at mga pagkakaiba-iba nito noong 1979. Ang Rete algorithm ay kasalukuyang ang pinaka mahusay na algorithm ng hinuha ng forward chain. Ang pangunahing ideya ay paghiwalayin ang mga tugma. Ang item na dinamiko ay nagtatayo ng isang tumutugma na puno batay sa nilalaman upang makamit ang isang makabuluhang pagbawas sa dami ng pagkalkula.

2.2 Paglalarawan ng Algorithm

Ang algorithm ng pagtutugma ng pattern na Rete ay isang pattern na tumutugma sa algorithm na gumagamit ng temporal na kalabisan ng engine ng hinuha at ang pagkakapareho ng istraktura ng panuntunan sa pagtutugma ng pattern upang mapabuti ang kahusayan ng hinuha sa pamamagitan ng pag-save sa gitna na lokasyon.

Sa proseso ng pagtutugma ng pattern, maaaring maraming mga magkaparehong mga module sa premise ng mga patakaran. Samakatuwid, kapag ang mga patakaran ay naitugma, isang malaking bilang ng mga paulit-ulit na operasyon ay gaganapin, na nagdudulot ng kalabisan sa oras. Hal:

RULE1: kung (A> B) at D o C pagkatapos ay E = 100
RULE2: kung (A> B) at (BRULE3: kung (! (A> B) o (B

Upang maitugma ang 3 mga patakaran na ito, kinakailangan ang tatlong mga kalkulasyon para sa expression A> B, at dalawang kalkulasyon ang kinakailangan para sa BB, M2 = B

RULE1: kung (M1) at D o C pagkatapos ay E = 100
RULE2: kung (M1) at (M2) pagkatapos E = 200
RULE3: kung (! (M1) o (M2)) pagkatapos E = 300

Muling kalkulahin lamang ang E1 kapag nagbago rin ang A o B, kapag nagbago ang B o C, muling kalkulahin ang E2. Ang nasabing pangangatuwiran ay iniiwasan ang paulit-ulit na parehong expression sa tuwing naisasagawa ang pagtutugma ng pattern, at kailangan lamang tuklasin kung ang mga kaugnay na parameter ay nagbabago upang matukoy kung i-update ang expression, na nakakatipid ng maraming oras at overhead sa proseso ng pangangatuwiran, sa gayong pagpapabuti ng kahusayan sa pangangatuwiran. .

3 Panimula sa dalawang pangunahing mga engine ng panuntunan

Ang pagtutukoy ng JSR94 ay tumutukoy sa isang hanay ng mga rules engine na JAVA API na naglalarawan sa mga pangunahing pagpapatakbo ng isang hanay ng mga engine ng patakaran. Ang kahulugan ng seryeng ito ng mga pagpapatakbo ay batay sa palagay na ang karamihan sa mga kliyente ay kailangang magsagawa ng isang multi-step na ikot ng engine engine: mga panuntunan sa pag-parse, paglalagay ng mga bagay sa engine, pagpindot sa mga panuntunan, at pagkuha ng mga resulta ng object mula sa engine.

Ang mga klase at interface na tinukoy ng pagtutukoy ay nasa mga javax.rules at javax.rules.admin packages. Ang mga klase at interface para sa rule engine runtime client ay kasama sa javax.rules, na nagbibigay ng isang paraan upang makakuha ng isang session ng panuntunan mula sa isang nakarehistrong tuntunin ng pagpapatupad ng panuntunan at makipag-ugnay sa session ng panuntunan. Nagbibigay ang pamamahala ng API ng mga pamamaraan para sa paglo-load ng mga hanay ng pagpapatupad ng panuntunan mula sa mga panlabas na mapagkukunan, kabilang ang mga URI, mga stream ng pag-input, mga dokumento ng XML, mga puno ng binary abstract syntax, at Mga Mambabasa. Kasama rin sa pamamahala ng API ang mga pamamaraan para sa pagrehistro at hindi pagrehistro ng mga hanay ng pagpapatupad ng panuntunan. Ang mga nakarehistrong panuntunan lamang sa pagpapatupad ng panuntunan ang maaaring ma-access sa pamamagitan ng runtime client API.

Halimbawa: Ang panuntunan ng engine ng Jess sa Sandia National Lab Drools na panuntunan sa engine sa open source software [5].

3.1 Si Jesus

Sa Jess, ang pagpapahayag ng mga panuntunan ay sumusunod sa istrukturang gramatika ng CLIPS, at sinusuportahan nito ang mayamang pattern ng pagtutugma ng wika sa pamamagitan ng pagtukoy sa mga panuntunan bago at post. Bilang karagdagan, sinusuportahan ni Jess ang isang diskarte sa programa na nakatuon sa proseso, na nagbibigay ng ilang mga pahayag upang makontrol ang daloy ng mga patakaran ng post, tulad ng paggamit kung ... pagkatapos ... iba pa at habang ... gawin ... mga pahayag, nang sa gayon samantalahin ang proseso na nakatuon sa proseso na napaka epektibo. Sa madaling salita, ang mga tampok na ito ni Jess ay nagbibigay sa system ng isang malakas na representasyon ng kaalaman.

Hal:

(defrule library- panuntunan- 1
(libro (pangalan? X) (status late) (nanghihiram? Y))
(nanghihiram (pangalan? Y) (address? Z))
=>
(nagpapadala- huli na paunawa? X? Y? Z))

Ang hanay ng mga patakaran na ito ay maaaring isalin sa Tsino tulad ng sumusunod: Maaaring maging ang panuntunang ito
Panuntunan sa Library # 1:
Kung mayroong isang overdue book na nagngangalang X, na hiniram ng taong nagngangalang Y, at alam ng Z ang address ng nanghihiram, padalhan ang Y ng isang X book tungkol sa Abisuhan sa Z [6].

3.2 Mga Drool

Ang Drools ay isang engine ng panuntunan dinisenyo para sa wikang Java batay sa Rete algorithm ng Charles Forgy's. Ang aplikasyon ng Rete algorithm sa mga interface na nakatuon sa object ay gagawing natural ang pagpapahayag ng mga patakaran sa negosyo batay sa mga bagay sa negosyo na mas natural. Ang Drools ay nakasulat sa Java, ngunit maaaring tumakbo sa parehong Java at .Net.

Nagbibigay ang Drools ng Declarative Programming at gumagamit ng Mga Tiyak na Wika ng Domain (DSL) upang tukuyin ang isang pattern ng Xml para sa problem domain, na maaaring magamit upang ilarawan ang domain ng problema ng gumagamit. Ang mga elemento ng Xml (Mga Elemento) at mga katangian na nilalaman sa mga DSL ay kumakatawan sa iba't ibang mga elemento sa domain ng problema. Halimbawa, ang isang itinakdang panuntunan ay isang Xml file na umaayon sa isang partikular na pattern (tingnan ang link para sa XmlSpy para sa mga detalye). Ang panuntunang 'wika' ay talagang paggamit ng Portal expression package, at maaaring mapalawak upang matugunan ang mga karagdagang kinakailangan ng rules engine.
Ang hanay ng panuntunan ng Drools ay may isang extension na .rls, na sa pangkalahatan ay may kasamang label, panuntunan, at ang bawat panuntunan ay tumutukoy sa isang kundisyong pagsubok at pagkilos.

Hal:



com.zhang.rules

x.getStatus () .equals ('y: borrower')
vo.setMassage (z, 'huling libro')

4. Konklusyon

Ang Java Rule Engine API (JSR-94) batay sa algorithm ng Rete ay nagbibigay-daan sa mga programa ng kliyente na makipag-ugnay sa mga produktong engine ng panuntunan mula sa iba't ibang mga vendor sa isang pare-parehong pamamaraan, na nagbibigay ng mga pagtutukoy sa pamantayan upang mamuno sa mga vendor ng engine sa ilang sukat. Ngunit mahirap na tukuyin kung ano ang isang engine ng panuntunan, at siyempre ay hindi napupunta sa kung paano ang mga panuntunan ay binuo at manipulahin, ang paggamit ng mga patakaran ay tumatawag, at ang pagbubuklod ng mga patakaran sa wikang Java. At ang JSR-94 ay hindi sapat upang suportahan ang J2EE [1]. Si Jess at Drools ay may kani-kanilang mga merito, ngunit ang pamantayan ng wikang panuntunan at ang karagdagang pagpapayaman ng JSR-94 ay mananatili upang mapag-aralan.

Pagkilala: Salamat kina Li Guangsheng, Zhang Heqing, at Ou Jianshen para sa kanilang tulong.

mga sanggunian

1 Browne P. Paggamit ng Drools sa iyong aplikasyon sa java ng negosyo. http://www.onjava.com/pub/a/onjava/2005/08/24/drools. html 08/2005
2 Rupp N A. Isang pagpapakilala sa proyekto ng Drools, http://www.theserverside.com/articles/content/Drools/article.html.05/2004
3 Siya Renjie, Liang Bing. Palitan ang code ng rules engine. http://blog.csdn.net/csdnloading/archive/2005/02/02/277276.aspx. 2004
4 Li Guole. Java Rule Engine at ang API nito. http: / / www- 128. ibm. com / developerworks / cn / java / j- java- rules / # IDACCWOB. 07/2005
5 JSR94: Java Rule Engine APIhttp: //jcp.org/en/jsr/detail? Id = 94.2005
6 Ernest J. Friedman- Hill .Jess, Ang Java Expert System Shell http://herzberg.ca.sandia.gov/jess. 1997