JSP vs Velocity what is better?

Question

What is better between JSP and velocity in - Performance - Ease of use - Ease of creating reusable components - Availability of open source 3rd parties - IDE support

Answer 1

Advantages of Velocity:

• strict separation of view from business logic
• simple syntax that can be understood by graphic designers

Answer 2

@Vartec: I don't think that the "strict separation of view from business logic" is a velocity feature that is not present in jsp. You can do business logic in jsp (more or less) but it's not recommended at all. But I agree in your point regarding the syntax.

Performance

JSP is compiled to Java, so I don't think that velocity is faster. (have not done benchmarks myself)

Ease of use

For designers: velocity For programmers: (IMHO) jsp, because it's closer to code

Ease of creating reusable components

JSP has lots of components Velocity has no components itself (not component oriented)

Availability of open source 3rd parties

I have seen far more projects using JSP or JSP related technologies than velocity. Maybe because velocity is really low level... :-)

IDE support

There are plenty of tools for jsp. Especially the eclipse jboss plugin/tool suite has a good jsp editor.

Plugins for Velocity are mostly not functional or pretty basic (you get lucky if you have syntax highlighting)

Update If you are looking for a templating engine now, I'd suggest to have a look at thymeleaf. It's comparably lightweight to velocity and can be used just to template some text based templates with a few lines of code or used as a full featured templating engine for example within a webapp.

Answer 3

The below is about Freemarker, but the comparisons are probably still relevant.

At this point in these two technologies' development, it seems like the primary reasons to choose one over the other are:

1. There is something specific that you need that is in one and not the other
2. You want to prevent view developers from putting Java scriptlets into JSP pages
3. Your developers are more comfortable in one than the other

Reasons that don't seem to have as much of an impact:

1. Speed. There are so many layers in a typical Java EE app that have a much greater impact than the couple of milliseconds more or less that a view renderer might take. In fact, this is probably the last layer I would tackle if my app was performing subpar.
2. IDE support. JBoss Tools provides a Freemarker editor, and JSP tools are well known.
3. Syntax. JSP 2 and Freemarker have virtually identical syntax for many basic operations, because of EL and JSTL.

Freemarker Example:

<#list foos as foo>
  <tr>
     <td>${foo.field1}</td>
     <td>${foo.field2}</td>
     <td>
        <#list foo.childObjects as child>
           <#if child.name == 'bar'>
              ${child.value}
           </#if>
        </#list>
     </td>
  </tr>
</#list>

JSP-EL-JSTL Example:

<c:forEach items="${foos}" var="foo">
  <tr>
     <td>${foo.field1}</td>
     <td>${foo.field2}</td>
     <td>
        <c:forEach items="${foo.childObjects}" var="child">
           <c:if test="${child.name == 'bar'}">
              ${child.value}
           </c:if>
        </c:if>
     </td>
  </tr>
</c:forEach>

Answer 4

Velocity or even better FreeMarker. In JSP you cannot have runtime dispatch for pojo hierarchies and everything is statically typed which is a pain. Moreover if you create many JSP2.0 custom tags (say more than 100-150) then your development-deployment cycle will slow down heavily due to inefficiencies of Jasper to resolve dependencies efficiently.

On the other hand JSP has great tool support.

slow JSP compilation references:

http://www.mailinglistarchive.com/users@tomcat.apache.org/msg10786.html

http://marc.info/?l=tomcat-dev&m=119377083422720&w=2

Answer 5

I'll focus on using a template engine, because that is what I have most experience with.

It depends on what you really want to do. Servlets in combination with Velocity (or FreeMarker for that matter) offer a very good seperation of logic and presentation. Templates are harder to test, because you would need to evaluate the template to be able to judge wheter the HTML (or whatever else the output format is) is correct. For JSP this can be done in your IDE of choice.

The big advantage of templates is that you can store these completely outside of your application and even update them while your application is running. This is something that is a little harder to do with JSP, although hot deployment comes pretty close.

Reusable components can be created by using the include functionality of the template engine.

Answer 6

The advantages of Velocity as per above miss a couple of very important things from the engineers perspective:

• strict separation of view from business logic (as above)
• simple syntax that can be understood by graphic designers (as above)
• compact code that is less of a nightmare to revisit later, see example link
• non-servlet container deployment means easy deploy anywhere

Those last two really make Velocity useful compared to JSP.

Answer 7

I don't know whether Velocity can be able to compete with JSP in all aspects but Velocity is faster and nuch easier.Efficiency of Velocity is 35 to 45% more if it is complicated webpages it may be reduced but still it is 5% more than JSP.

Answer 8

Velocity is better It adapts to many application areas It offers a simple, clear syntax for the template designer It offers a simple programming model for the developer Because templates and code are separate, you can develop and maintain them independently The Velocity engine easily integrates into any Java application environment, especially servlets Velocity enables templates to access any public method of data objects in the context