Java ee

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.

Java EE Tutorials - Java Enterprise Edition 2015-06-27

In part 1, I tried to explain the various “Editions” of Java, and mentioned that Java Enterprise Edition is very much a misnomer. In this post we will take a look at why this is, and what Java EE is actually all about.

It’s all about the Specs

If we want to get really technical, Java EE is not a runtime environment, nor is it a single technology. If you want to get really technical, Java EE is a collection of specification documents which define how several different enterprise technologies should work in Java.

Java EE Tutorials - Communication Breakdown 2015-06-27

There is no doubt that Java is a serious language made by smart people. Unfortunately, it is also the product of a for-profit corporation, and is currently maintained by yet another for-profit corporation. As a result, it is cared for not only by a team of crack developers, but also a marketing department. And that marketing department sure has screwed the pooch.

Java EE Tutorials - Introduction 2015-06-27

This summer I am mentoring a group of interns at my job. It has been an exciting experience so far, but also a very revealing one.

First, it re-emphasizes just how truly complicated enterprise software development can be. Veteran developers don’t often think about this. Most of us learned about all the layers and components and technologies that make up modern software slowly, over time. It is only when you try to teach it all at once, to someone with no experience with any of it, that you realize that something as seemingly “simple” as writing a basic Java webapp wired with Spring is actually really freaking complicated, and very difficult to explain.

Apache Shiro 2015-05-03

Throughout 2014 I encountered a lot of cool, new (to me) programming tools. Bourbon, AngularJS, node.js, Homebrew and iTerm2 have all become welcome additions to my toolbox in that time. But there’s one tool among them which I’ve loved the most - Apache Shiro. Shiro is a Java security framework that manages to do the unthinkable: it makes Java security easy. I advocate for it every chance I get, and the responses I get are always positive.