Programming

Java EE Tutorials - JSP Syntax 2015-08-13

In our last post, we wrote a basic JSP page and served it in a web application. Now let’s take a close look at JSP’s syntax and features.

The example code is located in the jsp_part_2 branch of our tutorial Github repository. The ZIP file can be found here.

JSP Expressions

The JSP code from our bare bones page was an example of a JSP Expression. Syntactically, they use the <%= … %> construct.

We saw how expressions are translated into Servlet code - they’re simply passed into a call to out.write(). That should give you a pretty good idea as to what is and isn’t allowed in a JSP expression. Keep in mind, however, that JSP expressions don’t end in a semicolon - if they did, the Servlet would have something like out.write(new java.util.Random.nextInt(););, which just wouldn’t compile.

Java EE Tutorials - JSP Basics 2015-08-12

Let’s take a look at the very basics of Java Server Pages.

Serving JSP Pages

JSP pages should be bundled in a Java web application. They’re placed in the same location as regular HTML pages - basically, anywhere other than the WEB-INF/ folder. Furthermore, you won’t have to configure anything in the web.xml file, and your web server will automatically compile and render the pagefor you (provided you are using a Java application server, like we have been thoughout these tutorials).

Java EE Tutorials - Java Server Pages 2015-08-12

We spent quite a few posts discussing Java Servlet technology, but now it is time to move onto another part of the Java EE stack - Java Server Pages. At this point there are number of paths we can start down, but since JSP’s both build upon and work closely with Servlets, it seems like a logical next step.

The Basics

First released in 1999, making the technology almost as old as Servlets.

JSP allows you to write HTML pages which contain embedded Java code. When you request the page, the server will run the embedded code, which usually renders more markup and other data. The final result is (or should be) a valid HTML page, which your web browser will then render.

Essentially, JSP pages are the Java equivalent to PHP, or the ERB templates that are used in Ruby on Rails.

Java EE Tutorials - Servlet 3.0 Features Part II 2015-07-19

This post is dedicated to discussing the asynchronous processing abilities of the Servlet 3.x family of specs.

I am going to warn you ahead of time that I’m not an expert at this stuff. If I get something wrong, you have my deepest apologies (and if you really want to be nice, please let me know of my error). With that out of the way, I’ll cross my fingers and get started.

Java EE Tutorials - Servlet 3.0 Features Part I 2015-07-19

Up until this point in our Java EE tutorial series, we’ve talked about absolutely nothing but Servlets. And unless I made a mistake, all of the code examples in prior posts should work using version 2.x or newer of the Servlet specification (and if did make a mistake, please let me know!). I had a good reason for doing this - version 3 of the Servlet spec introduces an alternate, backwards-incompatible method of configuring and deploying Servlets, and while I don’t have numbers indicating the adoption rate of Servlet 3.0 over version 2.x, I do know that enterprises are often slow to upgrade, meaning there’s a good chance that some shops still are (and will continue in) using 2.x Servlets. In that case, it made sense to use examples that are applicable to both environments.

However, now that we’ve covered all the core features, we can safely talk about the new, Servlet 3.0 specific stuff in their own post. All of these features are supported by the demo project we’ve been using. Now, let’s look at some features.

Java EE Tutorials - Servlet Listeners 2015-07-12

Our tour of the Java Servlet Specification is almost finished. So far we have covered Servlets, Filters, and the Servlet Context. Now we will look the last major Servlet feature - Listeners.

If you’ve spent enough time writing Java, chances are you have encountered the listener concept before. They wait for some event to occur, at which point they will trigger and perform some action. In general, listeners can be made to listen for any sort of event, but if we want to use the Servlet-specific listener classes provided by the API, we are limited to only a predetermined set of events. When you consider that the purpose of a Servlet is to simply process requests and responses, these events are really all you need.

The Servlet API provides several types of Listeners in the form of Java Interfaces. We aren’t going to cover all of the Listeners in this post, instead focusing on the most commonly used ones. The first is ServletContextListener, which listens for two events - when the Servlet Context is created, and when it is destroyed. The next interface is ServletRequestListener, which also listens to two events - when an incoming request is created, and when it is destroyed.

Java EE Tutorials - The Servlet Context and Friends 2015-07-11

So far our Java EE tutorial series has covered Servlets and Servlet Filters. Now we need to look a little deeper into the configuration and lifecycle of a Servlet.

When your web application fires up, the server is responsible for loading the classes and initiating each Servlet. This procedure is more complicated than simply calling a couple of init() methods. There are a variety of app-wide configuration options available to your web application, and these need to be made available to your code.

Java EE Tutorials - Servlet Filters 2015-07-06

In our last post, we went through the creation of a very basic Java Servlet, and bundled it up into an equally simple Java web application. We’ll go over some more complicated Servlet examples soon, but for now I want to take a look at one of the other components of the Servlet specification - Filters.

The purpose of a Filter is to intercept requests and responses in order to do something with them. This probably sounds redundant - after all, we already do something with these objects within the Servlet itself. The existence of filters, however, allows us to enforce good, modular design, as well as separation of concerns.

Java EE Tutorials - Our First Servlet 2015-07-05

In this post, we will look at how to write an incredibly simple Java web application with a single Servlet.

A few ground rules before we start. The code for this and future examples will be stored on Github. Here’s the link to the code used today:

https://github.com/taidan19/java-servlet-tutorial

If you aren’t using git, you can download the code as a ZIP file here

You can build and run the example with either Maven or Gradle, so take your pick. Whichever you choose, the example is configured to run in an embedded instance of the Jetty web server. Just type mvn jetty:run (in Maven) or gradle jettyRun in Gradle (hit Ctrl+C to shut the server down). With the server running, access localhost:8080/basic to see the web app. in action.

Java EE Tutorials - Servlets 2015-06-28

For our first Java EE deep dive, we will be covering Servlets. I don’t think it is a stretch to say that Servlet technology is the most useful and widely used feature in the entire Java EE stack.

The Basics

First released in 1997.
Servlets existed before the modern Java EE stack was codified.
Used as the building block for many other Java EE technologies.

If you want the dry, super technical definition of a Servlet, it is a special kind of Java class that is able to respond to requests. In practice, however, people really only use them to respond to HTTP requests in web applications. In fact, if you read the latest specification document for Servlets, it pretty much talks about HTTP Servlets exclusively.

Anyway, I find it easier to use Servlets than to explain how to use them, but it is worth explaining anyway, as they serve as a good example on how most Java EE technologies are developed with and deployed.