See discussions, stats, and author profiles for this publication at: https://www.researchgate.

net/publication/324828895

Model View Controller-A Comparative .NET Versus Java Analysis

Conference Paper · April 2018

CITATIONS READS
0 316

2 authors, including:

Octavian Dospinescu
Facultatea de Economie si Administrarea Afacerilor
45 PUBLICATIONS 79 CITATIONS

SEE PROFILE

Some of the authors of this publication are also working on these related projects:

World IT Project - Case of Romania View project

Research in Business Information Systems View project

All content following this page was uploaded by Octavian Dospinescu on 29 April 2018.

The user has requested enhancement of the downloaded file.

 Innovation Management and Education Excellence through Vision 2020

Model View Controller –

A Comparative .NET Versus Java Analysis

Dospinescu Octavian, Alexandru Ioan Cuza University, Iasi, Romania, [email protected]

Donu Bogdan-Andrei, Alexandru Ioan Cuza University, Iasi, Romania, [email protected]

Abstract
In this article we analyzed the Model-View-Controller paradigm (MVC) in detail through two
modern technologies (.NET and Java). Starting from MVC's evolution and concepts, we analyzed the
defining components of the model and conducted a comparative case study that looked at the
following aspects: security degree, total cost, application complexity, runtime, portability, user
interface. The results are presented in detail for each platform. After performing the comparative
analysis, we identified several future directions for the Model View Controller pattern.

Keywords: Model View Controller, MVC Analysis, future of MVC

Introduction - Evolution and Specific Components for Model View Controller

The evolution of Model View Controller

Technology is constantly evolving, and to be in the top is vital to keep up with the changes. Any
company that wants to be efficient must take advantage of new IT solutions to optimize their internal
processes. The complexity of applications is rendered by the interface, which changes at an alert
pace, with consistent differences compared to previous versions. The graphical interface is intuitive
and easy to use even for a simple user, but this is hard to test, and an application typically has more
interfaces. Because the user interface changes very often, emphasis has been placed on separating it
from the logical component behind and determining the behavior of the application.

Over time, there have been many solutions to this problem, but one of the most used and known in
web application development is the Model-View-Controller pattern. It was invented by Trygve
Reenskaug when he was working at the Xerox Palo Alto Research Center. His first work (Reenskaug
1979)was written in 1978, the original model being called Thing Model View Editor. The pattern was
first implemented as a SmallTalk-80 programming language library (Krasner and Pope 1988) and
was used to create Graphical User Interface (GUI).

The initial significance of the Model View Controller was very different from the meaning of the
model today. Below are the two models and the differences between them. In the context of a
graphical user interface (first version), Model View Controller was interpreted as follows (Walther
2008):
- the Model component: represents the data of an object/object structure in an application;
- the View component: a view of the model data, the same model being represented by
multiple views. For example, a grade can be written in numerical or lettering;
- the Controller component: collects the user input data and modifies the model. For
example, when double clicking on a web interface, it changes and displays something else (model
data has changed).

4728
 Innovation Management and Education Excellence through Vision 2020

Figure 1: The first representation of the MVC pattern

(Source: (Walther 2008))

It can be seen from the above figure that the View element is updated through the Model component
and not the Controller (between the Controller and the View component is not a link). Instead, the
Controller modifies the Model component and, as the View element observes the pattern,
pattern, the view is
updated. When the pattern changes, an event is triggered, and the changes in Visualization occur in
response to the event.

In the current version of Model View Controller, there is no longer any relationship between the
View and Model component. All communication between visual and persistence is achieved through
the Controller.

Figure 2 : The present MVC pattern

(Source: (Walther 2008))

The Model View Controller components

Model View Controller (MVC) is an architectural software model for deploying user interfaces on
computers. He divides a given application into three weakly interconnected parts (model, view, and
controller). This is done to separate the internal representations
representations of information from the way
information is presented to users. The relationships between the components of the MVC pattern are
illustrated in the following figure:

4729
 Innovation Management and Education Excellence through Vision 2020

Figure 3 : Relationships in the Model View Controller pattern

A software solution developed with the MVC architecture has the following mode of operation:

1. The user interacts with the interface (example: click on a radio button);
2. The controller receives this event, validates it and transmits it to the Model element;
3. The Controller also tells the Model that the state must change due to user interaction on the
interface (example: That radio-button could indicate the person's type, and after ticking an option (M
or F) the BD field is updated);
4. A View interrogates the Model in relation to the current state and the Controller sends it to the
View New State. (Example: View updated with old status plus gender confirmation)
5. The interface stays "static" until the next user action.

The Model component is the primary element of this architecture and explains the behavior of the
application, independent of the user interface. The model encapsulates data and procedures that help
in the specific processing of the application. Controllers call these procedures on behalf of the user,
and the View component displays the new changes that occur in the interface. The model also
provides functions that can access the data that is displayed. The change-propagation mechanism
maintains a dependency register within the model, which changes the element in the interface, the
View and Controller components are announced. The model is usually both a database and business
logic behind the application.

A view can be any form of representation of an output, such as graphs, tables or diagrams, and so on.
Each view is an update procedure that is enabled by the change-propagation mechanism. When a
procedure is called, the View component receives the current Model data and displays it on the
screen. The View is the interface of the software solution and transmits to the Controller all the
actions that take place.

The View component often offers the functionality that allows Controllers to manipulate the display.
This is useful for user-initiated operations that do not affect the Model (does not change Model data),
such as the scroll (no changes to the database).

A web application is usually composed of a set of controls, patterns, and views. The first component
can be structured in the form of a main Controller that receives all requests and calls the Controller
dealing with a particular case. Its role is to coordinate data between the two classes of objects
(Ibrahim 2006), (Sarker and Apu 2014).

The controller connects between Model and View, between user actions and the logical part of the
application. Depending on the user's needs, the Controller calls various functions specifically defined
for the site section in which they are located. This component contains the most code lines as it is the
means by which the user interacts with the application. Due to the fact that Model View Controller is

4730
 Innovation Management and Education Excellence through Vision 2020

an organizational pattern, not a concrete implementation technique, most modern platforms (.Net,
Java, Python, etc.) allow the use of this model by incorporating web frames that help the developer
structure application. Complex web solutions can have many code lines, so it's a good idea to
structure your application architecture right from the start. There are many techniques available to
create a web application, but all of these techniques have some advantages and disadvantages. In this
article, we'll focus on Active Server Pages (ASP) and Java Server Pages (JSP), which are two of the
most important techniques for implementing the MVC pattern. The Model View Controller pattern is
further shown for each platform specified above.

Model View Controller in ASP. Net MVC

Active Server Pages (ASP) .Net MVC is a web development framework offered by Microsoft that
combines the existing advantages of ASP .NET platform with the strengths of the Model View
Controller architecture. ASP .Net supports three major web application development models, namely:
through web forms, web pages, and Model View Controller architecture. In order to create web
solutions using the .Net MVC framework, we need Visual Studio, which contains a complete set of
development tools for any type of application (Freeman, Pro ASP.NET MVC 5 Platform 2014),
(Velasco 2017), (Freeman, Understanding Angular and ASP.NET Core MVC 2017).

Figure 4 shows how the main components of a web solution (developed using the MVC .Net ASP
framework) interact.

Figure 4 : ASP .Net MVC workflow

1. The user attempts to access the web page / resource through a URL (Uniform Resource Locator);
2. The HTTP request reaches the first component of the MVC architecture, this being the routing
engine (the routing engine);
3. Based on mapping between URLs and Controllers, the routing engine searches for the
corresponding URL controller. If the controller is found, it is invoked;
4. The controller interacts with the model based on the user's HTTP request. If data is received from
the user, the model is updated and the controller receives the new "status" of the application; 5. The
controller sends to the View component the current status of the application;
6. The controller sends the result received from View to the browser as part of the HTTP response;
7. The browser receives the HTML generated by the application.
ASP.NET framework assures the independence of the Model, View and Controller components
(separates business logic from UI logic), while providing a weak link between these elements and can
communicate.

4731
 Innovation Management and Education Excellence through Vision 2020

Model View Controller in Java

Web application development in Java can be done with the MVC Spring Web Framework. This
framework provides Model View Controller architecture and all the components needed to develop a
dynamic web solution. The main elements of a web application developed in Spring are the following
(Ahmed 2016):

- The model: encapsulates the application data and will generally be composed of POJO (Plain Old
Java Objects) classes. By using POJO classes, the code can be simplified, and this leads to better
application testing, flexibility, and so forth (Stark 2015).
- View: is responsible for rendering data in the HTML format so that the browser can interpret the
output (Kruk, et al. 2017);
- Controller: is the intermediate between the two elements specified above.
The following is how the elements of a web solution developed in Spring communicate.

Figure 5 : Spring MVC workflow

(Source: (Spring - MVC Framework 2018))

1. After receiving an HTTP request, DispatcherServlet (also called the Front Controller in some
versions of the MVC Spring Frame) communicates with Handler Mapping to establish the Request
Controller;
2. The controller picks up the request and calls the methods according to the type of request:
GET/POST etc. In turn, these methods will update the Model data and transmit the View Name to the
Dispatcher;
3. DispatcherServlet will communicate with ViewResolver (maps a real view of each view name) to
get the View View;
4. In the last step, the model is rendered and the output (HTML) required for the browser is
generated.
Finally, we will realize that using a pattern design, such as Model View Controller, will help us
develop a web application much faster. Using this pattern, web solutions will be easy to upgrade
(scalable), easy to test and easier to maintain.

ASP.Net MVC versus Spring Web MVC - Comparative Study

Obviously, Java and .NET have a different approach to web application development. However, both
platforms pursue the same goals and target the same market segment, namely scalable web
applications. In the literature there are some studies regarding the performance analysis of
applications written using MVP and MVC (Aygun and Kazan 2015). Below is presented how the
main elements of Model-View-Controller architecture are implemented in Java and .Net.

4732
 Innovation Management and Education Excellence through Vision 2020

For a better understanding of these implementations, we will create a class called "Student" and it
will have two attributes: "name" and "last name". The user can set and get the value of these
properties through the setters / getters, and besides, he can check using the isValid method if the
name / surname is valid

J2EE (Java 2 Platform, Enterprise Edition) vs. ASP .Net (Active Server Pages .Net)
- Model: In J2EE the model is represented by Java bean classes, and in ASP .Net simple classes with
setters and getters. Below is the code for both cases.

Figure 6 : The class “Student” iin Java Figure 7 : The class “Student” in
i .Net

The next main element to be explained is the view. It is built with tags (</>) and represents the most
visible component of the application, that is, the interface.

Figure 8: JSP simple form Figure 9 : ASP.Net simple form

Controller: To create a controller in J2EE, we need a class that inherits the "HttpServlet" class. The
controller logic is implemented by a method that takes two instances of the Servlet HTTP class as
parameters: a Servlet Request HTTP instance and one Response (Aniche, et al. 2017).

To create a controller in ASP.Net we need a class that implements the IHttpHandler and
IRequiresSessionState interface. Below is the code for both cases.

4733
 Innovation Management and Education Excellence through Vision 2020

Figure 10 : Controller class in

n Java Figure 11 : Controller class in .Net

Table 1 lists the main differences between applications developed using the MVC ASP.Net
framework and those developed with the Spring MVC framework.
frame

Table 1: Applications developed in ASP.Net MVC vs. Applications developed in Spring MVC

Features Applications developed in Applications developed in

MVC ASP.Net Java (Spring MVC)
Operating systems running They are especially designed It runs the same on any
for Windows users operating system
Developing environments ASP.Net is only available in the The Spring MVC Framework is
Microsoft Visual Studio available in several
development environment development environments
GUI (Graphical user interface) Microsoft tools allow us to Poor quality web interfaces
build more friendly interfaces
Complexity The framework is very well There are many ways to expand
structured and easy to use and configure, making the
Spring MVC a very complex
framework
Speed for complex web Web applications developed Web applications are moving
solutions with the MVC ASP.Net more slowly than those
framework are very fast developed in MVC ASP.Net
(one reason being that Java is a
multi-platform
platform programming
language)
Degree of Security The security level is lower Spring Security provides
features for authorizing all
layers in the system
Total costs The total costs are lower Total costs are slightly higher
because the MVC ASP.Net compared to the costs of the
framework includes all the other option
functionalities needed to
develop a complex web
solution (we no longer need
other frames)

4734
 Innovation Management and Education Excellence through Vision 2020

.NET and Java have long been on the market and are both modern development platforms. However,
when we have to make a decision about the platform we want to use, there are some main aspects can
be considered (RishabhSoftware 2017):

1. Complexity of the applications - the general perception is that .Net is easy over Java in terms of
solutions that need a richer graphical user interface. On the other hand, Java is over .Net for
applications that support a large amount of data or users.
2. Portability - As we have seen in the table above, Java has multi-platform compatibility and gives
us the freedom to choose the provider. Organizations choose Java when integrating the application
with the operating system is a priority.
3. Employee Software Development Skills - It is very important to take into account the
infrastructure and capabilities of today's developers because replacing and developing an
infrastructure can greatly increase costs.

Conclusion, Discussion And Future Directions

In conclusion, when choosing the programming language in which we want to develop the
application, we must take into account both the non-functional or technical requirements (for
example, application security, speed etc.) and functional (for example, how the computer system
should behave). However, our choice should not be based on a better architecture but should be based
on the strengths and weaknesses of the technologies and the extent to which the chosen platform
meets our established requirements.

MVC is widely used and many web applications are based on the pattern Model View Controller
Model View Controller can be found in two forms:

- Server side MVC (MVC on back end);

- Client MVC (MVC on the front end).

The View View Controller on the front end is usually built with a frame, developed in most cases in
JavaScript (for example, Angular Js). The Controller component also has a large part of the
application's behavior, but it is saved on the station (client) (Harms, Rogowski and Lo Iacono 2017).
The main difference between server-side MVC and client-side MVC is given by the way web pages
are rendered. In the first case, HTML is always fully loaded when we use the application, contrary to
the MVC on the front end where the HTML code is loaded and modified only in the parts where the
user acted.

In 2017, client-side applications were dominant, especially single-page software solutions - these
solutions load once the initial page and then request multiple pieces of data through Ajax calls. The
problem with these applications is that as users rotate around the page, they create a lot of Ajax
requests on the server, which slows the application (Moldovan 2016).
Model View Controller is now the best way to develop server-side applications, but this architectural
pattern can not be used on the client side because it does not respect its principles and component
independence (the View component is tightly linked by the Controller in this case).

Another problem encountered in the developed applications based on the client-side MVC pattern is
related to the data stored in the Model component. On the one hand, we have data such as users and
products, which are the status of the application, and on the other hand, we also need to store the
status of the interface through elements such as showTab or selectedValue. Similar to the problem
encountered in the Controller, the Model component violates the principle of unique responsibility
because there is no separate way to manage the status of the application and the state of the interface.

Recently, a number of new frameworks have been introduced that promote the unidirectional data
flow concept and solve the problems encountered in the client-side MVC pattern. In short, the new
architecture attempts to make predictable changes to the status of the application by imposing certain
restrictions on how and when updates can take place. The most notable architecture is Flux and the

4735
 Innovation Management and Education Excellence through Vision 2020

most notable framework is React (Simkhada 2017). For now, there are few software developers who
have adopted this method, but as they begin to uncover the benefits of unidirectional architectures,
many will head to that direction. Flux is the application architecture that Facebook uses to build web
client software solutions. It solves the problems encountered in the Model View Controller pattern
and respects the principle of unique responsibility using a one-way data stream (Flux in depth
overview 2015).

Given the above-mentioned arguments, it is expected that in the near future we will no longer use the
MVC classic architecture to develop front end applications, but only back end applications (based on
the server). Front end (client) software solutions will be developed with the new Flux architectural
pattern. Every day, more and more software developers begin to see the benefits of unidirectional
components and architectures, with the emphasis on building tools and better libraries in the future.

References

Ahmed, Mustafa. 2016. "Implementation of Course Scoring System Based on Spring MVC and
Hibernate." Culminating Projects in Computer Science and Information Technology 13.
http://repository.stcloudstate.edu/csit_etds/13.
Aniche, Maurício, Gabriele Bavota, Christoph Treude, Marco Aurélio Gerosa, and Arie van Deursen.
2017. "Code smells for Model-View-Controller architectures." Empirical Software Engineering 1-37.
doi:https://doi.org/10.1007/s10664-017-9540-2.
Aygun, Coskun, and Emre Kazan. 2015. "The Performance Analysis of Applications Written Using
MVP and MVC." INTERNATIONAL JOURNAL OF SCIENTIFIC RESEARCH IN INFORMATION
SYSTEMS AND ENGINEERING 1 (2). http://ijsrise.com/index.php/IJSRISE/article/view/33.
2015. Flux in depth overview. Facebook Inc. Accessed 2018. https://facebook.github.io/flux/docs/in-
depth-overview.html#content.
Freeman, A. 2014. Pro ASP.NET MVC 5 Platform. Apress, Berkeley, CA.
doi:https://doi.org/10.1007/978-1-4302-6542-9_1.
Freeman, A. 2017. "Understanding Angular and ASP.NET Core MVC." In Essential Angular for
ASP.NET Core MVC. Apress, Berkeley, CA. doi:https://doi.org/10.1007/978-1-4842-2916-3_1.
Harms, Holger, Collin Rogowski, and Luigi Lo Iacono. 2017. "Guidelines for adopting frontend
architectures and patterns in microservices-based systems." Proceedings of the 2017 11th Joint
Meeting on Foundations of Software Engineering. 902-907. doi:10.1145/3106237.3117775.
Ibrahim, N. 2006. "Applying a Model/View/Controller Pattern in J2EE Platform Using Struts
Framework." Jurnal Sistem Informasi 1 (2): 129-147.
http://jutisi.maranatha.edu/index.php/jusi/article/viewFile/205/203.
Krasner, Glenn, and Stephen Pope. 1988. "A Description of the Model-View-Controller User."
Journal of object oriented programming (ParcPlace Systems).
https://www.researchgate.net/profile/Stephen_Pope/publication/248825145_A_cookbook_for_using_
the_model_-_view_controller_user_interface_paradigm_in_Smalltalk_-
_80/links/5436c5f30cf2643ab9888926/A-cookbook-for-using-the-model-view-controller-user-
interface.
Kruk, G., O. Alves, L. Molinari, and E. Roux. 2017. "BEST PRACTICES FOR EFFICIENT
DEVELOPMENT OF JAVAFX." 16th Int. Conf. on Accelerator and Large Experimental Control
Systems. Barcelona, Spain: JACoW Publishing. 1078-1083. Accessed 2018.
doi:doi:10.18429/JACoW-ICALEPCS2017-THAPL02.

4736
 Innovation Management and Education Excellence through Vision 2020

Moldovan, A. 2016. Is Model-View-Controller dead on the front end? freeCodeCamp.

https://medium.freecodecamp.org/is-mvc-dead-for-the-frontend-35b4d1fe39ec.
Reenskaug, Trygve. 1979. "The original MVC reports." Accessed 2018.
http://heim.ifi.uio.no/~trygver/2007/MVC_Originals.pdf.
RishabhSoftware. 2017. Java vs .NET: Core Features and Differences Between the Two. Rishab
Software. Accessed 2018. https://www.rishabhsoft.com/blog/dot-net-vs-java.
Sarker, I.H., and K. Apu. 2014. "Mvc architecture driven design and implementation of java
framework for developing desktop application." International Journal of Hybrid Information
Technology 7 (5): 317-322. doi:http://dx.doi.org/10.14257/ijhit.2014.7.5.29.
Simkhada, Kumar. 2017. Transitioning Angular 2 User Interface (UI) into React. Helsinki. Accessed
2018. https://www.theseus.fi/bitstream/handle/10024/124681/thesis_final.pdf?sequence=1.
2018. Spring - MVC Framework.
https://www.tutorialspoint.com/spring/spring_web_mvc_framework.htm.
Stark, S.M. 2015. Providing a POJO-based microcontainer for an application server. USA Patent
US9009699B2. Accessed 2018. https://patents.google.com/patent/US9009699B2/en.
Velasco, Ryan. 2017. ASP.NET Multitenant Applications: For Starters. USA: CreateSpace
Independent Publishing Platform.
Walther, Stephen. 2008. "The Evolution of MVC." Accessed 2018.
http://stephenwalther.com/archive/2008/08/24/the-evolution-of-mvc.

4737
 Proceedings of
st
the 31 International Business Information Management Association Conference

(IBIMA)

25-26 April 2018

Milan, Italy

ISBN: 978-0-9998551-0-2

Innovation Management and Education Excellence through Vision 2020

Editor

Khalid S. Soliman

International Business Information Management Association (IBIMA)

Copyright 2018

View publication stats