International Journal of Engineering and Applied Computer Science (IJEACS)

Volume: 02, Issue: 07, ISBN: 978-0-9957075-8-0, July 2017

Model-Driven Generation of MVC2 Web

Applications: From Models to Code
Mhamed RAHMOUNI Samir MBARKI
Department of Computer Science, Faculty of Science Department of Computer Science, Faculty of Science
Ibn Tofail University Ibn Tofail University
Kenitra, BP 133, Morocco Kenitra, BP 133, Morocco

AbstractComputer systems engineering is based, subjected to. The models have always been used in computer
increasingly, on models. These models permit to describe the science as a basis for reflection. However, they have often
systems under development and their environment at different been relegated to the rank of simple documentation. Model-
abstraction levels. These abstractions allow us to conceive driven engineering aims to place models at the heart of the
applications independently of target platforms. For a long development process to make them the main elements
time, models have only constituted a help for human users, through which applications are generated. Taking model
allow to manually develop the final code of computer change into account and automatically generating systems by
applications. The Model-Driven Engineering approach (MDE) generation from these models seems to be a promising
consists of programming at the level of models, represented as
outcome to meet changing constraints.
an instance of a meta-model, and using them for generating the
end code of applications. The MDA (Model-Driven At the heart of model-engineering are placed the model
Architecture) is a typical model-driven engineering approach transformations. They realize the automation of essential
to application design. MDA is based on the UML standard to stages of software production: refinement and models
define models and on the meta-modeling environment (MOF) composition, reverse engineering, code generation and
[1] for model-level programming and code generation. The documentation, etc. These transformations are intended to be
code generation operation is the subject of this paper. Thus, in used repeatedly by development teams, for example in
this work, we explain the code generation of MVC2 Web software workshops. Therefore, it is crucial that they be
application by using the M2M transformation (ATL
validated and tested so that the developer can have full
transformation language) then the M2T transformation. To
implement this latter we use the Acceleo generator which is a
confidence in them.
generator language. In the M2T transformation, we use the The presented work is the continuation of the work
PSM model of Struts2 already generated by M2M presented in [39]. This work allows generate automatically a
transformation as an input model of Acceleo generator. This MVC2 web application that is a source code of an
transformation is validated by a case study. The main goal of application based on Struts2 framework [1]. To realize this
this paper is to achieve the end-to-end code generation. operation of code generation, we used ACCELEO [37] as a
code generation language. To achieve this code generation,
Keywords- MDA; PSM; Code Generation; Acceleo; Struts;
ATL transformation; MVC2 architecture
we begin by implementing the different templates
corresponding to each meta-class which is an element of the
I. INTRODUCTION PSM model already generated in [39]. After establishing the
different templates (Action classes and Jsp pages), we
In recent years, development of Internet, distributed, validate the automatic code generation with a case study.
embedded or self-managed applications has considerably
complicated the development of computer systems. These The remaining part of this paper is structured as follows:
are used in increasingly varied and constrained environments section 2 explains the process and methodology of this work.
(mobile terminals, cars, robots) and in increasingly critical Section 3 is devoted to the architecture of UML and Struts2
contexts (aerospace, medical, military, nuclear). In addition, meta-models. Section 4 is devoted to the transformation rules
during their lifetime, software is subject to constant evolution implementation. Section 5 is dedicated to the transformation
to satisfy user needs and adapt to new platforms. Academic rules execution and the result of execution process. Section 6
and industrial world are thus led to rethink the software presents the Model-to-Text transformation implementation.
production processes in order to adapt them to these new The Model-to-Text transformation result is dedicated to the
stakes. section 7. Section 8 presents the evaluation of this work.
Section 9 discusses the main related work, while section 10
A pragmatic vision to adapt to these changes is to allow wraps up the conclusions and future works.
the software production in automatic way in order to take
into account the inevitable evolutions which these are

DOI:10.24032/ijeacs/0207/04 www.ijeacs.com 217

Mhamed RAHMOUNI & Samir MBARKI International Journal of Engineering and Applied Computer Science (IJEACS)
Volume: 02, Issue: 07, ISBN: 978-0-9957075-8-0, July 2017

II. PROCESS AND METHODOLOGY class UMLDiagr...

In this work, we begin our process by the presentation of UmlPackage

the different meta-models (CIM, PIM and PSM). CIM model - name: String

is represented by an UML class diagram of a case study of an 1

Employee management. This UML class diagram is
+elements *
represented by an Ecore model. The PIM meta-model is an
Classifier
extract of UML class diagram meta-model. The PSM meta- 1
- name: String
model refers to the Struts2 meta-model. After models and 1 +type
meta-models, we define the different ATL transformation
rules. Then, we implement the KM3 models corresponding +type *

DataType
to each PIM and PSM meta-model then the different Ecore Class
+property
Property

models corresponding to these KM3. The next step is 1 *

-
-
name: String
upper: Integer
devoted to establish the traceability links between different 1
- lower: Integer

elements of source and target meta-models and thereafter we +operation

*
define the different transformation rules in ATL
Operation Parameter
transformation language. The ATL transformation result is a +parameter
- name: String - name: String
MVC2 web model represented in EMF model. In the end 1 * *

step, we use the generated PSM model as an input model of

Acceleo generator then we generate the application code of
Figure 1. An Extract of UML Class Diagram Metamodel.
the presented case study by applied a M2T transformation
based on the cited ACCELEO generator. In the case of M2T
transformation, we begin by the implementation of different B. Struts 2 Target Meta-model
templates corresponding to the Action classes and the JSP In this section, we present the Struts2 target meta-model.
pages. The work of this transformation is validated and This meta-model is explained in first time in [39]. The
exemplified by a case study. different elements that form the Struts 2 meta-model are as
follows:
The tools support of this work is the UML [14], ATL
transformation language [22]-[23]-[24], MOF [15], XMI ModelPackage: Presents the concept of UML
[16], KM3 [6], OCL [17], EMF Project [15] and Acceleo package. This package designates the notion of
[37]. Model in the MVC2 architecture.
The following section is dedicated to the M2M ControllerPackage: Expresses the Controller concept
transformation based on MDA approach and ATL in the MVC2 architecture.
transformation language [25]. In this section, we begin by ViewPackage: Indicates the concept of Views
presenting the different meta-models. package.
III. UML AND STRUTS2 META-MODELS ActionMapper: Represents the ActionMapper class
concept.
In this section, we explain the different meta-classes that
form the UML source and the target meta-models. ActionProxy: Expresses the ActionProxy class
concept.
A. UML Source Meta-model ActionInvocation: Expresses the ActionInvocation
Figure 1 presents the UML source meta-model. This class concept.
meta-model is a simplified UML model composed Action: Indicates the concept of action in the
essentially of packages containing the data types and classes. controller package.
The main elements of this metamodel are:
JspPages: Represents the Jsp package concept.
UmlPackage: This is an UML package concept. Result: Expresses the generated element through an
Classify: Represents the generalization concept of Action class.
meta-class. This latter represents both the concept of The Interceptors: Represents the concept of an
UML class as well as the data type concept. Interceptor package.
Class: Shows the UML class concept. Interceptor: Indicates the interceptor classconcept.
DataType: Explains the concept of UML data types. HttpRequest: Expresses the concept of
Operation: Represents the concept of UML class HttpServletRequest class.
methods.
HttpResponse: Designates the concept of
Parameter: Expresses the method parameters HttpServletResponse class.
concept.
Property: Represents the concept of UML class
properties.
DOI:10.24032/ijeacs/0207/04 www.ijeacs.com 218
 Mhamed RAHMOUNI & Samir MBARKI International Journal of Engineering and Applied Computer Science (IJEACS)
Volume: 02, Issue: 07, ISBN: 978-0-9957075-8-0, July 2017

class Struts2Mo...

ModelPackage
+controller
- name: String

Property
+property
+controller 1 - name: String
+pojo *
+pojo 1..* 1

POJO
+pojos +pojo
+views - name: String
0..*
View Package
+actionproxy
- name: String
+controller +actionproxy
ControllerPackage
ActionProxy
+views 1..* 1
- name: String +controller - name: String

+jsp 1..* +actionproxy 1

+model

JspPages 1 +actioninvocation
+actioninvocations
- name: String +acionmapper ActionInv ocation
*

+interceptor - name: String

ActionMapper
HttpResponse
+jsp +actionmapper +response
- name: String 1
1 1
1..*
+actions 1..*
+response 1..*
0..1 1
+actionmapper +interceptors
+action +actions
Interceptors
+result +action 1
Result Action
+request
+interceptors HttpRequest
- name: String 1..* - name: String
*
- class: String 1 0..1
+action
+interceptor
* 1
+action 1..*
+actioninvocation
+action 1..* +request 1

+interceptors Interceptor

1 - name: String
+interceptor-ref

1..*

Figure 2. PSM Struts2 Meta-model.

The different tools permits to achieve this work are: ATL

IV. TRANSFORMATION RULES IMPLEMENTATION plug-in integrated in Eclipse, XMI, OCL, KM3, UML, MOF
This section is dedicated to the transformation rules and EMF project.
implementation. It explains the different steps from The next section is dedicated to the implementation of rules
implementation to execution of different transformation rules. specification and then the definition and the execution of ATL
In first step, we implement the different meta-models like: transformation rules. Ecore and km3 meta-models are not
struts2.km3, struts2.ecore, UML.km3 and UML.ecore. In presented in this paper for letting it quite understandable and
second step, we establish the rules specification. Then, we clear.
define the different transformation rules based on these
specification rules by ATL language in a file named A. Rules Specification
UML2Struts2.atl. Finally, we implement the source model. This section is devoted to the presentation of the main rules
This latter is an UML class diagram of Employee management to transform an UML Class Diagram into Struts2 Web model.
represented in XMI language. The different specification rules are:

DOI:10.24032/ijeacs/0207/04 www.ijeacs.com 219

Mhamed RAHMOUNI & Samir MBARKI International Journal of Engineering and Applied Computer Science (IJEACS)
Volume: 02, Issue: 07, ISBN: 978-0-9957075-8-0, July 2017

An UML package generates a Struts2 package. V. TRANSFORMATION RULES E XECUTION

The Struts package is composed of a Controller In this section, we present a case study to demonstrate and
package and a View package. exemplify our proposition. The UML class diagram of this case
Each Controller Package is composed of a set of study represents the source model of our ATL transformation.
Action classes. The execution algorithm of ATL transformation allows
browsing all transformation rules and thereafter generates the
An Action class is composed of a set of Result classes. MVC2 web model. This latter is represented in figure 6.
An Operation generates an Action and a JSP pages.
A. Case study
B. Rules-Based transformation written in ATL The current case study is a system of a three classes. This
This section expresses the different rules which transform system makes it possible to manage an employee of a given
the UML class diagram into MVC2 web model. The different department. The different classes that compose this system are:
rules are: City class, Department class and Employee class. In this case
study, we elaborate only the CRUD operations (Create,
Rule 1: From Operation to Struts 2 Action Retrieve, Update, and Delete). These operations are most often
This rule represents the main rule of this transformation. implemented in all systems. Figure 4 presents the Ecore model
Thus, this rule allows generate the different action classes and equivalent to the UML class diagram of a department's
Jsp pages of each Action. The name of each jsp page is employees.
composed from the name of the operation concatenated with
the name of the class and followed by the extension .jsp. The
different rules that compose this main rule are as follow:
Rule 1: An Operation can generate an Action.
Rule 2: An Operation can generate a Result.
Rule 3: Each Result class is composed of a set of Jsp
pages.
The main rule is shown in figure 3. These rules are
implemented by ATL language.

Figure 4. Ecore model of a department's employees.

B. ATL Transformation Result

Figure 5 shows the generated MVC2 Web model of Struts2.
This model contains the different ingredients for implementing
a presentation layer respecting the architecture of MVC2
pattern.
The generated model is composed of a Struts package that
is composed of a set of Action classes and the View package
Figure 3. Main Rule : From Operation to Action. that is composed of a set of Jsp pages.

DOI:10.24032/ijeacs/0207/04 www.ijeacs.com 220

Mhamed RAHMOUNI & Samir MBARKI International Journal of Engineering and Applied Computer Science (IJEACS)
Volume: 02, Issue: 07, ISBN: 978-0-9957075-8-0, July 2017

VI. MODEL-TO-TEXT (M2T) TRANSFORMATION

IMPLEMENTATION
In this M2T transformation, we use the Acceleo [37] code
generator which is a code generator integrated into Eclipse. The
following section gives an idea of this generator then a brief
history of this latter.
A. ACCELEO Generator
Acceleo [37] is a source code generator of Eclipse
foundation that enables the implementation of MDA (Model
driven architecture) approach to realize applications from
models based on EMF. This is an implementation of the Object
Management Group (OMG) standard for model-to-text (M2T)
transformations.
The famous Acceleo project was born in 2006 around the
Acceleo.org website by Obeo. In its first versions, Acceleo 1.0
and 1.1 were at the time under GPL licence and compatible
with Eclipse 3.2 and many modelers based on EMF or UML. In
2009, for his passage to version 3, the project was admitted to
the Eclipse Foundation. From this transition, Acceleo changed
the language used to define generators to use the standard
OMG language for model-to-text transformation. This
language is an implementation of the MOFM2T standard.
ACCELEO is based on the concept of template approach.
B. Structure of ACCELEO project
According to the model already generated shown in figure
6, the ACCELEO structure project is composed of the
following principles elements:

1
The GenerateStruts2 package presents the
different generated classes (Bean and Action classes).
The org.eclipse.acceleo.ecore2java.files package
2
contains the main template explained in figure 8.

3
Represents the main template named
genStruts2.mtl.
Represents the main template named genStruts2.mtl.

4
Represents the template of Jsp pages.

The GenerateJsp folder 5 contains the different

JSP pages generated by code generation.
Figure 7 presents the created ACCELEO project and the
different packages and templates that constitute this project.
In the following section, we present the different templates
necessary to implement the automatic code generation by
ACCELEO and then to respond to our case study.
C. Code Generation Implementation
In this paper, we present the different templates permits to
generate the source code from PSM model (Figure 5) already
Figure 5. The Generated MVC2 Web model. generated by applying M2M transformation in [39].

DOI:10.24032/ijeacs/0207/04 www.ijeacs.com 221

Mhamed RAHMOUNI & Samir MBARKI International Journal of Engineering and Applied Computer Science (IJEACS)
Volume: 02, Issue: 07, ISBN: 978-0-9957075-8-0, July 2017

The generated PSM model implements only a CRUD

application that performs the operations of listing, adding,
modifying and deleting on a given entity. This use case is so
common in software development that it is rare to find an
application that does not do CRUD.
The aim of this paper is to implement the automatic code 1
generation of a Java web application allowing to make CRUD
on an entity model (UML class diagram) using Struts2 as a
presentation framework.
The automatic code generation by ACCELEO is based
necessary on the implementation of templates. In this paper, we
implement the templates correspond to the Action classes and
Jsp pages. The different templates needed to realize this project
are listed in the following UML class diagram shown in figure
7.

4
3

Figure 6. The Structure of Acceleo project.

Figure 7. UML class diagram of Main template corresponding to Struts2 Model.

DOI:10.24032/ijeacs/0207/04 www.ijeacs.com 222
Mhamed RAHMOUNI & Samir MBARKI International Journal of Engineering and Applied Computer Science (IJEACS)
Volume: 02, Issue: 07, ISBN: 978-0-9957075-8-0, July 2017

According to the figure 7, the principle templates are as

follow: Template Action and Template View. In this
section, we begin by implementing the Template Action then
in second hand we implement the Template View.
1) Template of Actions
The different templates which constitute the templates of
Actions, according to the figure 7, are as follow:
a) Template of Create Action class
This template permits to generate a Create class Action.
This latter allows insert or create a new employee, a new city
or a new department. The figure 8 shown below presents this
template.

Figure 9. Template of Retrieve Action Class.

c) Template of Update Action Class.

This template allows generate an Update class Action. This
latter allows modify an existing employee, an existing
department or an existing city. The figure 10 shown below
presents this template.

Figure 8. Template of Create Action Class.

b) Template of Retrieve Action Class

This template permits to generate a retrieve class Action.
This latter allows display all employees, departments and cities
existing in the BD. The figure 9 shown below presents this
template.

DOI:10.24032/ijeacs/0207/04 www.ijeacs.com 223

Mhamed RAHMOUNI & Samir MBARKI International Journal of Engineering and Applied Computer Science (IJEACS)
Volume: 02, Issue: 07, ISBN: 978-0-9957075-8-0, July 2017

Figure 11. Template of Delete Action Class.

2) Template of JSP pages

According to the figure 8, the different templates which
constitute the super template Template View are as follow:
Template of Create Jsp Page, Template of Retrieve Jsp
page, Template of Update Jsp page and Template of Delete
Jsp page.
Figure 10. Template of Update Action Class.
a) Template of Create Jsp page
d) Template of Delete Action Class. This template permits to generate a Create JSP page.
This page allows insert or create a new employee, a new city or
This template permits to generate a Delete class Action. a new department in the database. It represents the layer
This latter allows delete a selected employee from the existing presentation of the application. The figure 12 shown below
list of employees, departments or cities in database. The figure
presents this template.
11 shown below presents this template.

DOI:10.24032/ijeacs/0207/04 www.ijeacs.com 224

Mhamed RAHMOUNI & Samir MBARKI International Journal of Engineering and Applied Computer Science (IJEACS)
Volume: 02, Issue: 07, ISBN: 978-0-9957075-8-0, July 2017

department or city existing in database. The figure 14 shown

below presents this template.

Figure 12. Template of Create JSP page. Figure 14. Template of Update JSP page.

b) Template of Retrieve Jsp page d) Template of Delete Jsp page

This template permits to generate a Retrieve JSP page. This This template permits to generate Delete JSP page. This
page allows display all employees, all departments or cities page allows delete or destruct an employee, a department or
existing in database. The figure 13 shown below presents this city existing in database. The figure 15 shown below presents
template. this template.

Figure 13. Template of Retrieve JSP page.

c) Template of Update Jsp page

This template permits to generate an Update JSP page. This
page allows modify or update an employee, information of a

DOI:10.24032/ijeacs/0207/04 www.ijeacs.com 225

Mhamed RAHMOUNI & Samir MBARKI International Journal of Engineering and Applied Computer Science (IJEACS)
Volume: 02, Issue: 07, ISBN: 978-0-9957075-8-0, July 2017

Figure 16. The different generated classes.

In the next section, we present the different classes listed in

the above figure (Figure 16).
For letting this paper quite understandable and clear, we
present only one example of each Action class. We note that in
the application we arrived to generate all classes and all JSP
pages.
1) Create Action Class
This class is the result of M2T transformation by using the
ACCELEO generation language. The Create Action Class
CreateActionClass allows insert or create a new employee, a
Figure 15. Template of Update JSP page. new city or a new department. In this case, we present the
CreateEmployeeAction.java class. Figure 17 shows this
VII. MODEL-TO-TEXT TRANSFORMATION RESULT class.
According to the generated PSM model (Figure 5), the
different classes and JSP pages generated in this paper are
listed in the figure 16 for the Action classes and in the figure 21
for the JSP pages.
In the next section, we present the different Action classes
that are the CRUD Action classes.
A. Action classes Result
The Action class is one of Struts 2 novelties, the developer
is no longer constrained to extend a given class and frees up
J2EE objects to facilitate unit tests. It leaves the possibility of
creating a mother class for its controllers, in which you can
write all their common code (factorization) and which will
implement the "ActionSupport" interface. The different Action
classes generated in this paper are shown in the following
figure.

DOI:10.24032/ijeacs/0207/04 www.ijeacs.com 226

Mhamed RAHMOUNI & Samir MBARKI International Journal of Engineering and Applied Computer Science (IJEACS)
Volume: 02, Issue: 07, ISBN: 978-0-9957075-8-0, July 2017

3) Update class
This class is the result of a M2T transformation by using e
ACCELEO generation language. The Update Action Class
allows modify or update an employee, a city or a department.
In this case, we present the UpdateDepartmentAction that
permits to update the information of a given Department. The
figure 19 shown below presents this class.

Figure 17. Create Class Action:CreateEmployeeAction.java.

2) Retrieve Action class

This class is the result of M2T transformation by using the
ACCELEO generation language. The Retrieve Action Class
RetrieveActionClass.java allows retrieve or lists all
employees, all cities or all departments. In this case, we present
the RetrieveDepartmentAction.java class. Figure 18 presents
this class.

Figure 19. Update class Action: UpdateDepartmentAction.jsp.

4) Delete class Action

This class is the result of M2T transformation by using the
ACCELEO generation language. The Delete Action Class
DeleteActionClass allows delete an employee, a city or a
department from database. In this case, we present the
DeleteDepartmentAction.java. Figure 20 shows this class.

Figure 18. Retrieve Class Action:RetrieveDepartmentAction.java.

DOI:10.24032/ijeacs/0207/04 www.ijeacs.com 227

Mhamed RAHMOUNI & Samir MBARKI International Journal of Engineering and Applied Computer Science (IJEACS)
Volume: 02, Issue: 07, ISBN: 978-0-9957075-8-0, July 2017

5) Create Jsp page

This jsp page is the M2T transformation result by
ACCELEO generation language. The Create jsp page
CreateClass allows insert or create a new employee, a new
city or a new department in database. In this case, we present
the CreateCity.jsp jsp page. Figure 22 presents this jsp page.

Figure 22. Create JSP page:CreateCity.jsp.

Figure 20. Delete class Action: DeleteDepartmentAction.jsp. 6) Retrieve Jsp Page

This JSP page is the M2T transformation result by using
B. Generated JSP pages ACCELEO generation language. The Retrieve JSP page
The different JSP pages generated by ACCELEO generator RetrieveClass.jsp allows retrieve or lists all employees, all
is shown in figure 21. cities or all departments. In this case, we present the
RetrieveEmployee.jsp class. Figure 23 shows this class.
For letting this paper quite understandable and clear, we
present only one example of each JSP page. We note that we
have been able to generate all the requested JSP pages
according to the generated Struts2 model presented in figure 5.

Figure 21. The generated Jsp page

Figure 23. Retrieve JSP page:RetrieveEmployee.jsp.
DOI:10.24032/ijeacs/0207/04 www.ijeacs.com 228
Mhamed RAHMOUNI & Samir MBARKI International Journal of Engineering and Applied Computer Science (IJEACS)
Volume: 02, Issue: 07, ISBN: 978-0-9957075-8-0, July 2017

7) Update Jsp page VIII. EVALUATION

This jsp page is the M2T transformation result by using In this paper, we was conducted a process of code
ACCELEO generation language. The Update jsp page allows generation by using Acceleo generator. After generating this
modify or update an employee, a city or a department. In this code, we want to know the percentage of the generated code
case, we present the UpdateCity.jsp that permits to update with respect to the total application code. In this case study, we
the information of a given Department in database. Figure 24 obtained a very respectful percentage of code generation
shows this jsp page. occurred. The generated code has reached into 100% of total
code.
IX. RELATED WORK
After examining the related work concerning the automatic
code generation by applying MDA approach, we can cite
several works that are conducted in this domain such as: [26]-
[11]-[27]-[28]-[29]-[30]-[31]-[32]-[33]-[34]-[36].
The work presented in [26] permits to generate only JSP
pages and JavaBeans by applying the UWE [11] and ATL as a
transformation language [24].
The work cited in [27] permits to transform the PIMs
models implemented by Enterprise Distributed Object into
PSMs for different services platforms. The transformation rules
of this work are defined by ATL language. This work generates
only the PSM model.
In [28], Billing et al., explains the different transformation
rules permits to transform PIM into PSM in the EJB context.
The different transformation rules of this work are defined by
Figure 24. Update JSP page:UpdateCity.jsp. the approach by modeling based on QVT.
8) Delete Jsp page The work presented in [29] considers that MDA is a
This page is the result of M2T transformation by using software industrialization pattern (or a software factory). The
ACCELEO generation language. The Delete jsp page idea of this work is illustrated by a real case study in an IT
DeleteClass allows delete an employee, a city or a services company. The main objective is to create MDA tools
department from database. In this case, we present the founded on XMI, XSLT and Visitor pattern. .It is a proposal to
DeleteDepartment.jsp. Figure 25 shows this jsp page. create MDA tools taking as base XMI, XSLT and the Visitor
pattern.
In [30], the objective of this work is the model-driven
development approach for E-Learning platform. Thereby, the
authors implement the CIM model by analyzing business logic.
And thereafter, they establish the system diagram and the
robustness analysis. Thus, the authors define a transformation
method from PIM to PSM layer by layer.
In the work [31] the objective is to integrate a new
framework for secure Data Warehouses design by applying the
approach by modeling based on QVT.
In [32], the author presents the AndroMDA approach of the
community of web-based MDA [32]. This work permits to
transform a PIM schemes to model by integrating a wide
variety of scenarios and comes with a set of plug-ins, called
cartridge.
In [33], the authors arrived to generate a MVC 2 web model
from Struts framework. The meta-model of Struts is realized in
first time in this work. The different transformation rules of this
work are defined by ATL language in view to generate the
CRUD operations from three classes Ci, Cj and Ck.

Figure 25. Delete JSP page:DeleteDepartment.jsp.

DOI:10.24032/ijeacs/0207/04 www.ijeacs.com 229
Mhamed RAHMOUNI & Samir MBARKI International Journal of Engineering and Applied Computer Science (IJEACS)
Volume: 02, Issue: 07, ISBN: 978-0-9957075-8-0, July 2017

The subject of the work [34] is to generate the MVC 2 web method for considering other frameworks like: PHP, Zend and
model from the combination of UML class diagram and the DotNet.
UML activity diagram. The work presented in [35] is the
continuation of [34], the objective of this work is to generate REFERENCES
the code from the MVC2 web model already generated in [34] [1] Strsus2 homepage (2017). Retrieved June 4, 2017 from http:
by using the JET2 generator. //www.struts.apache.org/2.x/.
[2] Hibernate homepage. Retrieved July 4, 2017 from http: //hibernate.org/.
In [38], the authors arrived to generate the MVC2 web [3] Spring homepage (2017). Retrieved June 22, 2017 from http:
model, but in this case, from the combination of UML class //projects.spring.io/spring-framework/.
diagram and UML sequence diagram. This work is considering [4] Arnaud Cogolugnes, Thierry Templier, Julien Dubois , & Jean-Philippe
as an end-to-end code generation by using JET2 generator and Retaill (2nd Ed.) . Spring par la Pratique. 2009, Eyrolles.
based in the MDA approach. [5] GertiKappel, Birgit Prll, Siegfried Reich, & Werner Retschizegger.
Web Engineering. 2006, John Wiley.
The objective of the work presented in [36] is to generate
[6] Blanc, X., MDA en action : Ingnierie logicielle guide par les
the N-tiers PSM model by integrating Struts2, Spring IoC and
modles . Eyrolles, 2005.
Hibernate DAO frameworks. The different transformation rules
[7] Kleppe, A., Warmer, J., & Bast, W., MDA Explained: The Model
of this work are defined by ATL language. Driven Architecture: Practice and Promise. 2003, Addison-Wesley
The objective of the paper [37] is to generate the Struts2 Professional.
PSM model and to validate the ATL transformation rules [8] Stefano Ceri, Piero Fraternali, Aldo Bongio, Marco Brambilla, Sara
Comai, & Maristella Matera. Designing Data-Intensive Web
presented in this work which was not possible in [33]-[34]- Applications. 2003, Morgan Kaufman.
[35]-[36]-[38]. This paper describes a new validation method
[9] Jaime Gmez, & Cristina Cachero. OO-H: Extending UML to Model
of ATL transformation rules and the test of this method by a Web Interfaces. Information Modeling for Internet Applications. 2002.
case study. IGI Publishing.
[10] Pedro Valderas, Joan Fons, & Vicente Pelechano. From Web
Thus, we can say that the main contributions of our Requirements to Navigational Design A Transformational Approach.
approach compared to others are: the use of ACCELEO Proceedings of the 5th Int. Conference of Web Engineering (ICWE05),
generator to generate the code of Struts2 framework which was 2005, LNCS 3579.
not possible in the case of [34]-[35]-[38]. This work is realized [11] Koch, N., Transformations Techniques in the Model-Driven
for the first time in this paper. Development Process of UWE. Proceeding of the 2nd Workshopsh of
Model-Driven Web Engineering (MDWE06). 2006, Palo Alto.
X. CONCLUSION AND FUTURE WORK [12] Santiago Meli, & Jaime Gomez. The WebSA Approach: Applying
Model Driven Engineering to Web Applications. Journal of Web
Model-driven architecture (MDA) is a software Engineering, Vol.5, No.2, 2006.
development approach proposed and supported by the OMG [13] Object Management Group (OMG). Model Driven Architecture.
foundation. This is a particular variant of model-driven Document update/2012-06-27, Retrieved June 12, 2017 from
engineering (MDE). A typical example of MDA approach is http://www.omg.org/mda/.
the automatic generation of source code from UML modeling, [14] OMG. (2017, June). Unified Modeling Language. Available at :
which involves combining: The UML standard, the modeling http://www.uml.org/
tool that implements it and the UML generation templates. The [15] Meta Object Facility (MOF), version 2.0, Retrieved June 20, 2017 from
passage from the PSM to the code generation is the logical http://www.omg.org/spec/MOF/2.0/PDF/.
continuation of this treatment. It can be realized by generators [16] XML Metadata Interchange (XMI), version 2.1.1. Retrieved June 28,
such as these in order to produce any type of technological 2017 from http://www.omg.org/spec/XMI/.
targets. [17] Object Management Group (OMG) (2017). UML 2 Object Constraint
Language (OCL). Retrieved June 30, 2017 from
In this paper, we generate a MVC2 web code from Struts2 http://www.omg.org/cgibin/doc?ptc/2005-06-06.
model already generated by applying an ATL transformation. [18] Pan Yuqing, & Wang Jiuli. Design And Implementation of Accounting
This is the M2M transformation. After that, we implement the E-Business Platform for Source Documents. Proceeding in the
International Conference on Computer Application and System
model-to-text transformation based on the MDA approach in Modeling (ICCASM 2010). 2010, DOI:
view to obtain the code of this application from the generated 10.1109/ICCASM.2010.5622916.
model. Thereby, this transformation is started by the M2M [19] Spring AOP homepage. Retrieved June 8, 2017 from
transformation to obtain the PSM Struts2 model. The http://static.springsource.org/spring/docs/2.5.x/reference /aop.html.
generated PSM model is an EMF model. This latter is used, in [20] Praveen Gupta, & Govil, Prof. M.C., Spring Web MVC Framework for
the M2T transformation, as an input model of Acceleo rapid open source J2EE application development: a case study.
generator to produce automatically the necessary target International Journal of Engineering Science and Technology, Vol.2,
No.6, 2010, pp.1684-1689.
application code. Finally, the code generation result was
[21] Praveen Gupta, & Govil, Prof. M.C., MVC Design Pattern for the multi
demonstrated and exemplified by a case study. framework distributed applications using XML, spring and struts
Furthermore, we plan to generate an e-commerce web code framework. International Journal on Computer Science and
Engineering, Vol.2, No.4, 2010, pp.1047-1051.
from a PSM model result of the integration of struts2, Spring
[22] MENET, L., Formalisation dune Approche dIngnierie Dirige par
IoC and Hibernate DAO. In other hand, we can extend this les Modles Applique au Domaine de la Gestion des Donnes de
Rfrence. PhD thesis, Universit de Paris VIII, Laboratoire

DOI:10.24032/ijeacs/0207/04 www.ijeacs.com 230

Mhamed RAHMOUNI & Samir MBARKI International Journal of Engineering and Applied Computer Science (IJEACS)
Volume: 02, Issue: 07, ISBN: 978-0-9957075-8-0, July 2017

dInformatique Avance de Saint-Denis (LIASD), cole doctorale : AUTHORS PROFILE

Cognition Langage Interaction (CLI), 2010
[23] Frdric Jouault, & Ivan Kurtev, Transforming Models with ATL. M'hamed RAHMOUNI received the Diploma
Proceeding in MoDELS 2005 Workshops, LNCS 3844, 2006, pp. 128 of Higher Approfondie Studies in Computer
138, Springer-Verlag Berlin Heidelberg.
Science and Telecommunication from the faculty
[24] Jouault, F., Allilaire, F., Bzivin, J., & Kurtev, I., ATL: A Model
of science, Ibn Tofail University, Morocco, 2007,
Transformation Tool. Sciences of Computer Programming-Elseiver,
Vol.72, No.1-2, 2008, pp.3139. and Doctorat of High Graduate Studies degrees
[25] AtlanMod (2017). Atl transformation language home page. Retrieved in Computer Sciences from Ibn Tofail University,
January 20, 2017 from http://www.eclipse.org/m2m/atl/. Morocco, January 10, 2015 . He participated in
[26] Kraus, A., Knapp, & A., Koch N., Model-Driven Generation of Web various international congresses in MDA (Model
Applications in UWE. Proceeding in the 3rd International Workshop on Driven Architecture) integrating new technologies XML, EJB, MVC, Web
Model-Driven Web Engineering, CEUR-WS, Vol. 261, 2007.
Services, etc. and he published many papers in the MDA domain.
[27] Bezivin, J., Hammoudi, S., Lopes, D., & Jouault, F., Applying MDA
approach for web service platform. Proceedings of the 8th IEEE
International Entreprise Distributed Object Computing Conference Samir MBARKI received the B.S. degree in
(EDOC04), 2004, pp.58-70. Applied Mathematics from Mohammed V
[28] Bezivin, J., Busse, S., Leicher, A., & Suss, J.G., Platform Independent University, Morocco, 1992, and Doctorat of High
Model Transformation Based on TRIPLE. In Middleware04: Graduate Studies degrees in Computer Sciences
Proceedings of the 5th ACM/IFIP/USENIX International Conference on from Mohammed V University, Morocco, 1997.
Middleware, 2004, pp. 493- 51. In 1995 he joined the faculty of science Ibn Tofail
[29] Ndie, T. D., Tangha, C., & Ekwoge, F. E., MDA (Model- Driven University, Morocco where he is currently a
Architecture) as a Software Industrialization Pattern: An Approach for a Professor in Department of Computer Science. His research interests include
Pragmatic Software Factories. Journal of Software Engineering &
Applications, Vol.3, No.6, 2010, pp. 561-571. software engineering, model driven architecture, software metrics and
[30] Cong, X., Zhang, H., Zhou, D., Lu, P., & Qin, L., A Model- Driven software tests. He obtained an HDR in Computer Science from Ibn Tofail
Architecture Approach for Developing E-Learning Platform, University in 2010.
Entertainment for Education. Proceeding of Digital Techniques and
Systems Lecture Notes in Computer Science, Vol. 6249/2010, 2010, pp.
111-122, DOI: 10.1007/978-3-642-14533-9-12.
[31] Soler, E., Trujillo, J., Blanco, C., & Fernandez-Medina, E., Designing
Secure Data Warehouses by Using MDA and QVT. Journal of
Universal Computer Science, Vol.15, No.8, 2009, pp.1607-1641.
[32] AndroMDA (2017). Retrieved January 15, 2017 from http:
//www.andromda.org/.
[33] RAHMOUNI, M., & Mbarki, S., MDA-Based ATL Transformation to
Generate MVC2 Web Models.International Journal of Computer
Science & Information Technology (IJCSIT), Vol.3, No.4, 2011, pp.57-
70.
[34] RAHMOUNI, M., & Mbarki, S., Combining UML Class and Activity
Diagrams for MDA Generation of MVC 2 Web Applications.
International Review in Computers and Software (IRECOS), Vol.8,
No.4, 2013, pp.949-957.
[35] RAHMOUNI, M., & MBARKI, S., An End-to-End Code Generation
from UML Diagrams to MVC2 Web Applications. International
Review in Computers and Software (IRECOS), Vol.8, No.9, 2013,
pp.2123-2135.
[36] RAHMOUNI, M., & MBARKI, S., MDA-Based Modeling and
Transformation to Generate N-Tiers Web Model. Journal Of Software
(JSW), Vol.10, No.3, 2015, pp. 222-238, DOI: 10.17706/jsw.10.3.222-
238.
[37] Acceleo : https://www.eclipse.org/acceleo/ (Retrieved June 22, 2017)
[38] RAHMOUNI, M., & MBARKI, S., Model-Driven Generation: From
Models to MVC2 Web Applications. International Journal of Software
Engineering and Its Applications (IJSEIA), Vol.8, No.7, 2014, pp.73-94,
http://dx.doi.org/10.14257/ijseia.2014.8.7,07.
[39] RAHMOUNI, M., & MBARKI., S., Validation of ATL Transformation
to Generate a Reliable Web Models. International Journal of
Engineering and Applied Computer Science (IJEACS), Vol. 2, No. 3,
April 2017, pp. 83-91, DOI: 10.24032/ijeacs/0203/01.

2017 by the author(s); licensee Empirical Research Press Ltd. United Kingdom. This is an open access article
distributed under the terms and conditions of the Creative Commons by Attribution (CC-BY) license.
(http://creativecommons.org/licenses/by/4.0/).

DOI:10.24032/ijeacs/0207/04 www.ijeacs.com 231