JSP is a
Java view technology running on the server
machine which allows you to write template text in (the client side
languages like HTML, CSS, JavaScript and so on). JSP supports the
so-called
taglibs
which are backed by pieces of Java code with which you can control the
page flow and/or output dynamically (programmatically). A well known
taglib is
JSTL. JSP also supports
Expression Language
which can be used to access backend data (actually, the attributes
which are available in page, request, session and application scopes),
mostly in combination with taglibs.
When a JSP is requested for the first time or when the webapp starts
up, the servlet container will compile it into a class extending
HttpServlet and use it during the webapp's lifetime. You can find the generated source code in the server's work directory. In for example
Tomcat, it's the
/work
directory. On a JSP request, the servletcontainer will execute the
compiled JSP class and send the generated output (usually just
HTML/CSS/JS) through the webserver over network to the client side which
in turn displays it in the webbrowser.
Servlet is an
Java application programming interface (API)
running on the server machine which can intercept on the requests made
by the client and can generate/send a response accordingly. A well known
example is the
HttpServlet which provides methods to hook on
HTTP requests using the popular
HTTP methods such as
GET and
POST. You can configure
HttpServlets to listen on a certain HTTP URL pattern, which is configureable in
web.xml, or more recently with
Java EE 6, with
@WebServlet annotation.
When a Servlet is requested for the first time or when the webapp
starts up, the servlet container will create an instance of it and keep
it in memory during webapp's lifetime. The same instance will be reused
for every incoming request whose URL matches the servlet's URL pattern.
You can access the request data by
HttpServletRequest and handle the response by
HttpServletResponse. Both objects are available as method arguments inside any of the overridden methods of
HttpServlet, such as
doGet() and
doPost().
JSF is a
component based MVC framework which is built on top of the Servlet API and provides
components in flavor of
taglibs which can be used in JSP or any other Java based view technology such as
Facelets. Facelets is
much more suited to JSF than JSP. It namely provides great
templating capabilities such as
composite components, while JSP basically only offers the
for templating, so that you're forced to create
custom components
with raw Java code (which is a bit opaque and a lot of tedious work in
JSF) when you want to replace a repeated group of components by a single
component. If you can, I recommend to drop JSP and go for Facelets when
you want to develop with JSF.
As being a MVC (
Model-View-Controller) framework, JSF provides the
FacesServlet as the sole request-response
Controller.
It takes all the standard and tedious HTTP request/response work from
your hands, such as gathering user input, validating/converting them,
putting them in model objects, invoking actions and rendering the
response. This way you end up with basically a JSP or Facelets (XHTML)
page for
View and a Javabean class as
Model. The JSF components are been used to bind the view with the model (such as your ASP.NET web control does) and the
FacesServlet uses the
JSF component tree to do all the work.
http://stackoverflow.com/questions/2095397/what-is-the-difference-between-jsf-servlet-and-jsp
