Java se

Java EE Tutorials - JPA 2016-01-25

After 15 posts, it is time for this tutorial series to move on from Servlets (and related technologies) in order to cover another part of the Java EE stack - the Java Persistence API, or JPA.

Before we discuss the what and the why of JPA, let’s talk a little about JDBC.

JDBC

If you write Java code for long enough, you’ll find yourself using JDBC sooner or later. And for good reason; it is easy to configure without having to pull down tons of dependencies, and low level enough that you can make it do whatever you want.

That being said, when you find yourself working on a large, database-intensive application, JDBC starts to show its limits. For instance, it would require you to write and manage a ton of hand written SQL statements, and since each database has a slightly different SQL syntax, these statements won’t be portable if you ever switch DB’s.

Additionally, if your database rows are large and complex, you will have to pick through the ResultSet objects returned by JDBC to extract for each column one by one. In short, JDBC is nice to have around, but for certain situations it is more trouble than it is worth.

Java EE Tutorials - JSP and the JSTL 2015-10-04

In our last post, we talked about how to write custom JSP tags and add them to a taglib. Today we will go over the most famous taglib of all. The JSTL, or Java Standard Tag Library, is exactly what its name says it is. And like the rest of the Java EE family, it is defined by a specification, and implemented by a servlet container. The library tries to define tags which perform the most common tasks you might use on a JSP page, so that you don’t have to write them yourself.

The example code for this post can be found in the jsp_jstl branch of our example repository on Github, and a ZIP file of the code can be found here.

Java EE Tutorials - JSP Custom Taglibs 2015-09-07

Our tour of Java Server Pages wraps up with a discussion of custom taglibs. The example code for this post can be found in the jsp_taglib branch of our example repository on Github, and a ZIP file of the code can be found here.

So far, we’ve only looked at how to directly inline Java code into our JSP pages. This approach does its job, but it doesn’t have a lot of fans among Java developers, for reasons we’ve discussed before (code gets messy, business logic gets stuffed into the presentation layer, etc). This is where custom taglibs come into play as an alternative.

Java EE Tutorials - JSP and MVC 2015-08-17

Today we will be looking at how Java Server Pages are used in Model-View-Controller setups. The example code can be found in the jsp_part_3 branch of our example repository on Github, and a ZIP file of the code can be found here.

I mentioned in our introduction to JSP that JSP is often used as the View component in many Java-based MVC frameworks. Unfortunately, if you aren’t familiar with MVC, this isn’t the best time and place to explain it in detail. Suffice to say that in order for JSP to be feasible as the View component, it needs be able to accept real data so that it can render it on the page. So far, none of our previous examples have demonstrated this capability, but rest assured that it does exist.

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.