Rule languages and inference engines incorporate reasoning capabilities in Web information systems. In this paper, a Model-Driven Development (MDD) approach for automatic code generation of rulebased Web applications is proposed. A rule-based model specifying domain expert knowledge and business logic through production rules (ifcondition-then-action) becomes the source model for the development approach. Demonstrating our proposal, a tool supports the creation of rule models and the automatic execution of model-to-model and modelto-code transformations. As a result, a rich, functional, rule-based Web architecture is generated, based on the Model-View-Controller architectural pattern and the JavaServer Faces technology, and integrating a Jess rule engine to perform inference tasks.
The design of rule languages and inference engines to provide Web information
systems with reasoning capabilities is an important Semantic Web research topic
[
This paper addresses the development of rule-based systems embedded in Web applications to provide Web systems with inference capabilities, applying a model-driven approach to automate the development process of rule-based Web applications.
The terms Model-Driven Architecture (MDA) [
In this work Conceptual Modeling Language (CML) [
To put our proposal into practice, a supporting tool developed using several
tools provided by the Eclipse Modeling Project3 applies a model-driven approach
to rule models and automatically generates the implementation of a functional
rule-based Web application. The resulting Web architecture is based on the
Model-View-Controller (MVC) architectural pattern and the JavaServer Faces
(JSF) framework [
The proposed approach materializes InSCo [
This paper is organized as follows: Section 2 introduces rule-based systems and rule modeling languages for the Web. Next, the rule-based modeling approach for specifying the Web applications proposed is described in section 3. After that, the model-driven method for rule-based Web application development is detailed in Section 4. The MDD support tool is presented in Section 5. Section 6 describes related work, and nally main conclusions and future work are summarized.
Rule-based systems originated in Arti cial Intelligence, as the kind of expert or
knowledge-based system that use rules as knowledge representation formalism. In
this kind of software system, the human expert's knowledge applied for solving a
complex task such as diagnosis, monitoring, assessment, and so on, is represented
as a set of declarative production rules. Rule engines are able to interpret the
rules, and reason using some inference method to come to a conclusion as the
human expert would do [
In general, a rule-based system consists of a set of production rules, a working memory and an inference engine. The rules encode domain knowledge and business logic as condition-action pairs. The working memory initially represents the system input, but the actions that occur when rules are red can cause the state of the working memory to change. The inference engine runs a reasoning method to re rules, typically forward and backward chaining mechanisms. The execution of the action part of a rule involves inferring new data.
More recently, the software engineering community has also focused on rules
as a proper formalism for representing business logic in software systems. Today
these two points of view have merged, favoring the widespread adoption of
rulebased systems and business rules in the implementation of complex
decisionmaking processes [
Rule formalisms are an active area of research addressing the development
rule languages and inference engines to add reasoning to complex information
systems. The Object Management Group (OMG) proposed the Ontology
Definition MetaModel [
We use CML as the rule-modeling language because, although it is currently not one of the most common options for rule modeling, it has several features desirable for production-rule formalisms. It enables uni ed representation of ontologies and rules, in which rules and ontology are naturally related. It meets the requirements of rule representation formalisms, such as modeling rule antecedent, rule consequent, named rules, and rulesets, binding rules to ontology concepts, and so on. And nally, it is simpler and easier to use than other formalisms, although this may mean less expressiveness in certain situations. 3
The proposed model-driven approach for rule-based Web application development focuses on introducing rule modeling in the speci cation of Web applications. However, other modeling concerns related to Web design features must be also considered, powering the automatic code generation process. The CML model describing the ontology and rule model is presented at a conceptual level, whereas interaction and presentation features are speci ed at a Web design level. 3.1
The CML formalism for knowledge modeling entails the speci cation of simplied domain ontologies and production rules. A CML (domain knowledge) model is basically composed of two elements, domain schemas and knowledge bases. Domain concepts, binary relationships, rule types and value types (enumerated literals) are Kmnowoleddegeled in a domain schema. A knowledge base is composed of
Model instances of concepts, instances of relationships called tuples, and instances of rules. Figure 1 showsDotmhaien domain knowledge model components.
Knowledge
Domain Schema
Knowledge
Base Concepts
Rule Types Binary Relations
Value Types
Instances of Concepts
Instances of Rules
Tuples
CML was originally de ned as a textual notation by means of an abstract grammar described in EBNF (Extended Backus-Naur Form). To use CML in the context of MDD, we have speci ed a metamodel for CML. The main di erence between this formalism and other conceptual modeling approaches in software engineering, such as UML class diagrams, is its ability to model production rules with rule type and the rule instance constructors. A rule type describes the structure of a set of rules through the speci cation of the ontology types bound to the rule antecedent and consequent. Rule types are particularized into rule instances which represent speci c, logical dependencies between rule antecedent and consequent concept attributes. 3.2
CML models are enriched with interaction and presentation characteristics to specify rule-based Web applications design features.
Interaction features enable the speci cation of user interactivity through a set of properties associated to CML constructors. The following properties dealing with attribute management will illustrate some interaction characteristics: { isDerived. This property is set to true when the attribute value is inferred by the rule engine, so it cannot be edited by the user. { noti esTo and isNoti edBy : These properties are used to indicate what attributes must be refreshed by the re-rendered AJAX facility in a user event, for example a mouse click or a change in the attribute value.
Conceptual Model
Visit codeVisit : Symbol month : Month date : Date finished : Boolean Visit_to_PlotOfLand
visits [*] : Visit notifiesTo plot : PlotOfLand possibleStages [*] : PhenologicalStage phenology : PhenologicalStage Rule Instance : Phenology-abstraction visit.month = January visit_to_plotOfLand.possibleStages = (A,B1,B2)
M D D C o d e G e n e rit a o n
Web form page
Visit Date Finished Plot [PlotOfLand] Phenology event=”onchanged”
reRender PossibleStages
A - Dormant bud B1 - Bud swell B2 - Wooly bud
Figure 2 shows an example of how the interaction between two attributes de ned in the conceptual model is speci ed using the isDerived and noti esTo properties, showing how they a ect Web forms for editing instances. The example is taken from SAVIA, a decision-support system for pest control in greenhouse crops and grapes that is being developed by applying rule-based modeling and the proposed model-driven approach for rule-based Web system development. The left side of Figure 2 shows a selection of SAVIA conceptual rule model elements. In particular, a concept called Visit, a relationship called Visit to PlotOfLand, and an example of rule instance belonging to the group of rules that specify the possible phenological stages of the crop depending on the date of the visit. The concrete rule instance is: "if the month of the Visit is January then the possibleStages are (A, B1, B2)". Focusing on interaction speci cation, the possibleStages attribute is derived since it is inferred by the rule engine when it res rules such as the one above. And the attribute date of visit noti es possibleStages, making that when the event onChange happens in the Web form date eld, then an action makes the rule engine run and the list of possibleStages is re-rendered, updating the list with the new values determined by the rule engine.
Presentation features specify the conceptual model element's visibility properties, enabling user interface customization. For example, this makes it possible to select what concepts will appear in the application menu, and what attributes are included as columns of tables showing all instances of a concept type.
Although the two MDD processes are executed independently of each other, the nal result must integrate the rule base into the Web application. This is done by the appropriate method calls to the Jess API (Application Programming Interface) in the Java code generated, entailing integration of the rule engine into the Web application.
The rule-based Web application generated bene ts of having the decision
logic externalized from core application code, since uncoupling the rules from the
source code increases scalability and maintainability of rule-based applications
[
+inModule
RModule - moduleName : String - rulemetamodel : String - outputFilePath : String 1 +funInModule1 1 +extends 0..1 +owner +factTemplates 0..* RFactTemplate - factName : String 1
+rules 0..*
RRule - ruleName : String - ruleType : RRuleType +factTem0p.l.a+*tfeactTe0m..*plate -- dSeaslicernipcteio:nIn1:tSetgreinrg 1 0..* +functions {ordered} 0..* RFunction
- functionName : String +actions - parameters [0..] : String
0..* -- fruentucrtnioVnaTluyepe: S:RtriFnugnctionType {ordered} 0..* +Slot {ordered}
RFactSlot - slotName : String - slotValueRange : String - slotCardinality : RSlotCardinality - slotType : String <<enumeration>> RSlotCardinality - slot - multislot +condition 0..1RCondElem - ceName : RCondElemEnum +ceMatchPattern1 0.*.* +childCE 1
RPa0t.t.e*rn 0..* +c+ecMeMatacthcPhPatatettrenrn 1 0..* {ordered} 0..* +slotMatchExp RSlotMatchExp - slotName : String - matchExp : String <<enumeration>> RFunctionType - system - userdefined <<enumeration>>
RRuleType - constraint - initialization +defFacts 0..*
RDefFacts - defName : String - documentation : String +facts 0..*
RDefFact - factName : String 0..* +queries
RQuery - queryName : String - documentation : String - quetyType : RQueryType +variables {ordered} 0..*
RVariable - varName : String +slots 0..* +slotValue
RDefSlot RDefSlotValue - slotcardinality : RSlotCardinality 1..* - value : String - slotName : String <<enumeration>>
RQueryType -- aalFFaacctBtsyKey
In the Jess rules metamodel, a metaclass is de ned for each Jess language element. The root element of a Jess rule model is RModule. A module contains fact templates, rules, functions, facts and queries. The RFactTemplate metaclass models fact templates, the Jess constructor for storing information.
RRule enables the representation of rules. A rule has a ruleName, a property called salience that determines the order in which applicable rules are red by the rule engine, a containment reference condition representing the rule's condition part (antecedent), and a reference called actions representing the rule's action part (consequent). RPattern and RSlotMatchExp metaclasses de ne pattern matching expressions in rule conditions. Actions are function calls that assert new facts, or retract or modify existing facts.
Facts are de ned by the RDefFacts metaclass. Facts are acquired from instances of concepts in the CML source model. Finally, RQuery models queries to consult the working memory at runtime.
The mapping from CML rule-based models to Jess rule models is designed by a M2M transformation which maps each CML metamodel constructor to one or several Jess Rule metamodel elements. The Jess rule model generated by the M2M transformation is the source model for a M2T transformation which automatically generates the Jess rule base source code, producing a Jess le (.clp) with a code for every element included in the Jess rule model. The M2T transformation is designed using JET, as described later in this paper. 4.3
A second MDD process is applied (see Figure 3) to generate a Web architecture that integrates rules into a Web application. In this process, Jess rules can be integrated into the Web application, since both the Jess rule base and the Web architecture are generated from the same CML model.
Figure 5 shows the proposed target architecture for rule-based Web applications, based on the MVC architecture pattern, the JSF framework and rich AJAX JBoss Richfaces components.
Web Browser
Apache Tomcat Application Server
JavaEE Platform
JSF +
RichFaces Jess rule engine
Jess rule base
Jess facts
The integrated rule engine manages the Jess rule base and the text le containing persistent facts. The Web application enables the user to perform four basic predetermined functions, create new instances, read the current list of instances, update and delete instances. That CRUD operations are executed on the Jess rule engine working memory, enabling the inference mechanism to re appropriate rules when necessary. The rule engine executes a forward-chaining inference mechanism to drive the reasoning process, ring the rules with conditions evaluated as true, and executing their actions to infer new information or modify existing one.
A metamodel for the JSF Web architecture was designed. In the M2M and M2T transformations from a CML model to a JSF model and nally to code, each concept is mapped to several elements, a JavaBean class, a JSF page for instance creation and edition, a JSF page for listing all instances of that concept type, and a managed bean to be included in the con guration le. Interaction and presentation features are taken into account at this level in model-driven processes.
As a result, the use of both rules and AJAX technology improves the creation and edition of instances in the Web application. Since Web forms are implemented with AJAX RichFaces components, each single form value can be validated and submitted individually as it is entered. This facility entails the rule engine ring suitable rules and inferring new information that drives the instance creation or edition, for example, updating choice- eld values. 5
Our rule-based Web application model-driven development approach is demonstrated by our proof-of-the-concept, the InSCo-Gen tool. InSCo-Gen was developed using MDD tools provided by the Eclipse Modeling Project. Models and metamodels were de ned using the Eclipse Modeling Framework (EMF4), including three metamodels, the CML metamodel for conceptual models, the Jess Rule metamodel used for representing Jess platform-speci c models, and the JSF metamodel used by Web-based speci c models.
Conceptual models conforming to the CML metamodel are created using
the built-in re ective EMF editor. In order to improve model speci cation, the
re ective editor is customized using Exeed (EXtended Emf EDitor) [
Modeling certain aspects of Web design, such as interaction and presentation, is implemented in di erent ways. Whereas interaction features are added to the conceptual CML metamodel through metaclass properties, presentation is de ned by a set of XML con guration les, which can be edited by the developer before generating the Web application code.
Two M2M transformations are designed with Atlas Transformation Language (ATL5). The rst one maps a CML model to a Jess platform-speci c model. The second one transforms a CML model into a JSF-speci c model.
The outputs of both ATL transformations are the inputs of two M2T
transformations implemented with Java Emitter Templates (JET6). As a result,
InSCoGen automatically produces the Web application code, on one hand, source text
les with Jess rules and facts, and on the other, the Web application components,
the faces-con g.xml and web.xml con guration les, the Java Beans for model
classes, and a Jess-Engine Bean which uses the Jess Java API (Application
Programming Interface) to integrate the rule engine into the architecture. Moreover,
a set of JSP/JSF web pages are generated for the user interface. These pages are
based on the RichFaces library [
Our proposal uses the CML rule and ontology modeling formalism as the MDD
source model. To put CML into the MDD framework, we de ned a metamodel
for CML. The de nition of a UML Pro le for the speci cation of CML knowledge
models is addressed in [
Some previous work has proposed the generation of Jess rules from ontology
and rule models, such as OWL (Ontology Web Language) [
An MDD approach to Web Applications based on MVC and JavaServer
Faces is described in [
Regarding MDD of Web applications integrating rules, [
In this paper, rule-based and model-driven techniques are intertwined for the development of rule-based Web applications. The main contribution of our work is to enrich the speci cation of Web applications with a rule modeling formalism, introducing a new concern in Model-Driven Web Engineering. A model-driven approach for generating Web implementation enhanced with inference features is described and demonstrated by an MDD tool.
The resulting rule-based Web architecture implements the MVC architectural pattern using the JavaServer Faces framework, and incorporates rich JBoss Richfaces components to enhance the user interface with AJAX capabilities. The Jess rule engine is embedded in the Web application to provide inference capabilities. Our proposal does not include a navigation model, since application functionality is predetermined by CRUD functions.
Due to the declarative nature of rules, the decision logic is externalized from core application code producing Web applications easier to maintain and evolve.
The approach is being evaluated through its use in the development of a Web decision-support system for pest control in agriculture, which makes recommendations to growers and technicians about the necessity of treating a speci c pest or disease in grapes.
As future work, it is planned to use other ontology and rule modeling
languages such as OWL and SWRL as source models for the model-driven
approach, and de ne interoperability modules with other rule formalisms. Di
erent rule platforms, such as JBoss Rules [
Acknowledgments. This work was supported by the Spanish Ministry of Education and Science under the project TIN2004-05694, and by the Junta de Andalucia (Andalusian Regional Govt.) project P06-TIC-02411.