So, what's the agenda?
In our previous article we compared the MVC implementation for J2EE and ASP.NET
without using frameworks; to view that comparison click
ASP.NET MVC
and J2ee MVC.
In today's world no one implements MVC without the help of frameworks. So
whether it's ASP.NET or J2EE, a framework support is a must. Struts 2 has been
the most accepted framework in J2EE while in ASP.NET the ASP.NET MVC template is
the king. In this article we will compare these frameworks in terms of how they
differ in implementation and their positive and negative points.
In this article we will compare both frameworks using 8 agenda points:
- Automation
- Passing data between controller to views
- URL customization
- Security
- Folder structure management
- Intellisense support
- HTML automation (helper classes).
Do watch our .Net interview questions and answers
video from this link .NET interview
questions and answers; you can also catch our
J2ee Design
pattern videos from this link Java J2EE Design pattern.In case you are new to ASP.NET MVC and J2EE Struts frameworkIn case you are not aware of the frameworks you
can see the videos below to just get a quick start in both the frameworks.
Click here to view simple ASP.NET MVC video which displays a hello
world.
Click here to view simple J2EE struts video to teach struts 2 with
the help of an example.
Overall Comparison with framework
Before I even start, the following is a full
comparison sheet which gives an overall view of the comparison. We will be
discussing this in more detail as we proceed in the article.
Comparison points | Microsoft MVC 2 template | MVC using J2ee framework (Struts 2) |
Template Automation | In built with Visual studio | Need to use open source plug in likehttp://mvcwebproject.sourceforge.net/ |
Passing data from controller to view. | New session management techniques like "viewdata" and "tempdata" are introduced. | Uses the same request object inherently using same request interceptor. |
Readymade folder structure | The MVC template creates a readymade logical folder structure for view, controllers and model. | Does not have a logical folder structure like ASP.NET MVC, but can be created manually. |
Strong typed views for intellisense | Has string typed view support for better intellisense. | Achieved by using type casting. |
Helper classes | Helper classes | Tag libraries |
URL customization and action mapping | Uses behind code. | Uses the Struts 2 XML file. |
URL validation | URL validation can be done easily using regex. | Currently no inbuilt mechanism but can be achieved by customized coding. |
Security | Has readymade security attributes by which we can avoid cross site, SQL injection. | Currently no inherent feature but can be achieved by customized codin |
Automation using template
The first thing that caught our eyes is the
Microsoft VS IDE which has a nice readymade template from where developers can
start. In the MVC J2EE framework the core struts framework does not have
something inherent as Microsoft MVC does.
After everything is said and done, it does not
mean J2EE community is lagging; you can still use an open source plug-in; get
the template from
http://mvcwebproject.sourceforge.net/. The following is a simple snapshot of
MVC web project template.
The only difference it's not inherent like Microsoft MVC.
Conclusion: - Definitely Microsoft wins
here in terms of more user friendly interfaces and automation due to the MVC
template. In the J2EE struts framework we need to hunt for a third party plugin
which will help us to achieve the same kind of automation.
Passing data from controller to view
In MVC one of the most crucial features is
transferring data from controller to view. Microsoft MVC introduces a new
variable called 'ViewData' which will help us to transport data between
controller and view as shown in the following code snippet.
The following code snippet sets data in the controller.
ViewData["CurrentTime"] = DateTime.Now.ToString();
The following code snippet displays data on the view.
The J2EE Struts framework uses the HTTP request object to pass data from controller to the view. The following
code snippet sets a simple date value to the request object using the "setAttribute" function. In ASP.NET MVC we
cannot change the request object.
request.setAttribute("CurrentTime",new Date());
Later we can display the data using "getAttribute".
Conclusion: - The first thing is that both technologies have the ability to pass data, but somehow the J2EE Struts
framework thought process is more convincing. At the end of the day the view gets a HTTP request, so it's more
logical to pass data using the request objects rather than creating a new variable like view data for it.
Many ASP.NET MVC fans (which includes me) can also argue logically that the request object is created using the
data sent by the end user i.e. from the browser. This data should not be allowed to be changed in between by the
web application code. The request object should only be allowed to be modified by the end user using POST and GET.
For this I will give an equal point to both of them for now.
Readymade folder structure
In ASP.NET MVC the template creates a readymade
folder structure (they are termed as areas) which gives a developer a clear
picture of where to store the model, views and controllers as shown in the
following figure.
In J2EE struts framework we do not have the clear
cut vocabulary for folders as we have in ASP.NET MVC. In J2EE framework the
controller and model lies in the Java resources folder, while the views are
saved in a web content folder as show in the diagram below.
After everything is said and done you can always
manually rename and create a different folder structure to have the same logical
representation as we have in ASP.NET MVC , only that it's not automated.
As per our knowledge the above logical structure is not possible currently by
using any J2EE struts plug-in either.
Conclusion: - ASP.NET MVC has a slight
advantage in terms of better project management due to readymade logical folder
structure, while in J2EE framework we need to create them manually.
Strong type views for intellisense
In ASP.NET MVC you have a nice option where you
can create a strongly typed view. In other words when you add a view you can
select the model with which this view will connect.
Later when you go in the view and type model
keyword you can get the strongly-typed properties of the object.
In Java we do not have the concept of a strongly
typed view. If you want you can set the object in request.getAttribute and then
do a type cast to get the object intellisense.
Conclusion: - This feature can look very
exciting for the ASP.NET community but it was bit amusing for my J2EE friends (I
think they are right in a lot of ways also). The whole purpose of strong typed
views in ASP.NET MVC is for better intellisense which we can achieve by type
casting data from view data object as shown in the following figure.
The biggest problem here is that developers can
start thinking that the model has tied up the view. We understand the intention
is not that, but the dialog box just makes a visual intention of doing it. The
end goal of MVC is to separate the model from the view.
So concluding it's a good feature to get mofre
from less code but it can be confusing for junior developers who are working on
MVC. For a small automation I hope we do not end with a logical confusion about
MVC fundamentals.
Equal points again to both. I am not giving an extra point to ASP.NET MVC since
the view thing is more confusing and can be achieved by typecasting.
Helper classes
A good MVC framework will always provide helper
classes to create HTML code for views.
In ASP.NET MVC we have the helper classes. For instance to create a simple HTML
form in ASP.NET MVC you can use the HTML helper class as shown in the following
code.
In the J2EE struts framework we have tag
libraries which help us to generate the HTML code as it is done by using the
ASP.NET MVC HTML helper classes.
Conclusion: - Both the frameworks have
HTML helper classes. Let's not get into which library is better or else we will
lose focus of our main comparison. So even points to both the framework on this
discussion.
URL customization and action mapping
MVC is all about actions and these actions are
mapped to an URL. As a developer you would love to see your MVC framework have
the capability of customizing and configuring the MVC URL with action mapping.
The following is a simple table which explains why developers would expect
customization and configuration for MVC URL's.
Incoming URL | Controller | Action | Description |
http://www.questpond.com/LocateProduct | SearchProductController | Search | This action will help us to get all products. |
http://www.questpond.com/LocateProduct/100 | SearchProductController | Search(1001) | This action will help us to get all products with code 1001. |
http://www.questpond.com/Create | MaintainProductController | Create | This action will help us to create a new product. |
http://www.questpond.com/Modify/1001 | MaintainProductController | Modify(1001 | This action will help us to modify product with product code 1001. |
In ASP.NET MVC this is achieved by using the inbuilt routing mechanism. In order
to configure routes you can go to the global.asx.cs code and use the routes
collection to map the URL structure with the controllers and actions.routes.MapRoute(
"HelloWorld", // Route name
"Pages/RegisterAction/{1}", // URL with parameters
new { controller = "Register", action = "RegisterAction", id = UrlParameter.Optional }); // Parameter
defaults
In order to configure MVC URL in J2EE struts framework we can use the Struts XML file to do that. The following
mapping is cleaner than the routing collection of ASP.NET MVC. In J2EE framework we can see the mappings better
as they are mapped directly to page names.
Conclusion: - J2EE Struts framework definitely wins in terms of MVC URL configuration and mapping to the
controller as its defined using XML file. This could be a real improvement for the ASP.NET MVC framework. To
change the mapping, compiling code is more of a burden.
URL validation
In ASP.NET MVC we have the advantageous ability
to use URL validation using a regex (regular expression) before the action hits
the controller. For instance the following is a simple validation where, before
the view of the customer action is called, we can check that the input to the
action is only a numeric value with 2 digits.
routes.MapRoute(
"View", // Route name
"View/ViewCustomer/{id}", // URL with parameters
new { controller = "Customer", action = "DisplayCustomer", id = 0 }, new { id = @"\d{1,2}" }
);
Currently J2EE struts framework does not support that; after everything is said and done you can always still do
validation after hitting the controller using some custom logic.
Conclusion: - This is definitely a plus point for ASP.NET MVC because MVC URL's can be invoked from any medium,
via browser, via URLs etc. So we would like to ensure that appropriate validation is adequately checked before it hits
the controller.
Security
MVC URLs are mapped to an action and they can be
invoked directly which also means that they are subjected to cross-site attacks
such as SQL injection etc. The ASP.NET MVC framework has provided security
attributes by which we can protect our URL from such attacks.
For instance to prevent forgery attacks and cross-site scripting attacks we can
use the 'HtmLAntiForgeryToken()' as shown in the following code snippet.
In the actions later you can then check if there was any violation.
[HttpPost] [ValidateAntiForgeryToken]
public ActionResult Delete(int customerid)
{
}
You can also mark the controller by use of a validate input attribute to avoid CSS.
[ValidateInput(true)]
public class OurController : Controller
The critical functions on which you do not want actions to be invoked you can mark the methods as "nonaction" as
shown in the following code snippet.
[NonAction]
public void DoPasswordChange(string username, string newpassword)
{
/* Rest of code unchanged */
}
In the J2EE Struts framework currently we do not have any inherent security function to achieve the same. Some
customized code.
Conclusion: - This is the biggest win for ASP.NET MVC framework security. Hope that J2EE struts framework in the
future has such a kind of inherent security feature which will be a great extra benefit for the framework.
Final conclusion
The following is the final conclusion. ASP.NET MVC framework out performs J2EE
in 4 things while J2EE has the flexible XML URL customization which is currently
not available in ASP.NET MVC. For all the other points both of them remain on
the same page.
I have tried my level best to be fair and balanced and while doing so I never
had in my mind that I am an ASP.NET
Microsoft MVP and that I should hard sell ASP.NET MVC framework. I have made
by best effort to make a true comparison and see which one of them is the best.
I do understand how every developer loves his technology, by any chance I have
hurt anyone ... BIG SORRY.
Thanks Vishwa
Special thanks to Mr. Vishwanathan Narayanan who
helped me to give inputs on the J2EE side without which I would not have
achieved this. You can see his Java and J2EE design patterns videos by clicking
on Java J2ee
Design pattern videos.