Enterprise Java

Java EE 8 MVC: Getting started with Ozark

About a year ago a new action based MVC framework, simply called MVC, was announced for Java EE 8. MVC (specified in JSR 371) is based on JAX-RS and integrates with Java EE technologies like CDI and Bean Validation. The reference implementation for MVC 1.0 is Ozark.

This is the first article of a multi-part tutorial I am planning to write about Java EE MVC. In this post we will see how to get a basic Java EE MVC application running with Ozark. Upcoming articles will provide more details to specific sections.

Getting started with Ozark

Please note that the MVC specification is still an early draft, the final specification is planned to be released in Q3 2016. To have a look at Java EE MVC in this early state, we need a recent nightly build version of GlassFish and the current Ozark milestone release. The Ozark team recommends GlassFish b13 03-16-2015 for the current Ozark version.

Besides GlassFish we need the following dependencies to create an MVC application:


As mentioned above, Java EE MVC is based on JAX-RS. So things might look very familiar to you, if you already know about JAX-RS.

To create our MVC application we first need a JAX-RS Application class:

public class GettingStartedApplication extends Application {


This subclass of javax.ws.rs.core.Application can be used to define additional JAX-RS components. In this example we do not need any special configuration, so the class can stay empty. With @ApplicationPath we define the base path for our application.

Creating the Controller

A controller is responsible for processing incoming requests. Based on the incoming request it executes business logic, updates the model and returns the view that should be rendered. A simple Java EE MVC Controller looks like this:

public class HelloController {

  Models models;

  public String sayHello(@QueryParam("name") String name) {
    String message = "Hello " + name;
    models.put("message", message);
    return "/WEB-INF/jsp/hello.jsp";

The Controller class is annotated with @Controller and @Path. This indicates that the class is a Java EE MVC Controller that listens for requests on /getting-started/hello.

With CDI an instance of Models is injected to the controller. The Models class represents the MVC model. It is filled with data by the controller and is then passed to the view. Models is basically a Map<String, Object> that can contain arbitrary data.

The sayHello() method processes incoming HTTP GET requests (indicated by @GET). With @QueryParam request parameters can be bound to method parameters. Inside sayHello() the request parameter name is used to create a text message, which is then added to the Model. The returned String defines the path to the view that should be rendered.

Creating the View

Views in Java EE MVC applications are typically HTML pages with CSS and JavaScript files. In this example our view is a simple JSP file located at /WEB-INF/jsp/hello.jsp

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE html>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>Getting started</title>

Inside JSP files, model properties can be accessed via EL. Here, we use ${message} to access the model value with the key message.

The Java EE MVC specification defines two standard template engines for views: JSP and Facelets. However, other template engines can easily be integrated. We will have a look at the integration of other view technologies in an upcoming post.

Running the application

Now we are ready to start GlassFish and deploy our new MVC application. After that, we can send a GET request to our controller and see what it returns. Do not forget that the controller expects a name parameter.

For example GET /getting-started/hello?name=john will result in a HTML page containing the message Hello John.


Java EE MVC is the new upcoming Java MVC web framework. It uses a lot of existing Java technologies like JAX-RS, CDI and JSP. The framework itself is quite simple and easy to understand. The complete MVC 1.0 specification is only around 33 pages long and very easy to read.

We can use the current milestone release of the MVC 1.0 reference implementation Ozark to get a feeling for the upcoming Java EE 8 framework.

  • You can find the full source code of the example application on GitHub.

Michael Scharhag

Michael Scharhag is a Java Developer, Blogger and technology enthusiast. Particularly interested in Java related technologies including Java EE, Spring, Groovy and Grails.
Notify of

This site uses Akismet to reduce spam. Learn how your comment data is processed.

Newest Most Voted
Inline Feedbacks
View all comments
Luis Fernando Planella Gonzalez
Luis Fernando Planella Gonzalez
8 years ago

Another bogus “standard”.
I work with Java web development professionally for around 15 years and have never ever touched JSF.
Spring MVC and several others are probably much richer and better…

sumit bisht
sumit bisht
8 years ago

So what exactly is the new part (apart from few annotations) ?
This passing of ball between different frameworks is the reason why people are leaving server side java programming in doves.
Please clarify whether this framework does something apart from sugar coating the syntax.

Rolando Mota
Rolando Mota
8 years ago
Reply to  sumit bisht

Really???? I wasn’t aware of that, last time I checked Java remained as one of the most widely programming languages out there, specially for backend development. Probably you were talking about Java as a choice for FRONTEND development, which I could probably agree with you.

Jan Mikkelsen
8 years ago

Another Struts-like JSP based framework??
No thank you. I’ll just keep using Wicket.

Gilbert Lopez
Gilbert Lopez
7 years ago

I tried running the application on Tomcat 9 which has support for JEE 8. It doesn’t work. I get a 404 error at http://localhost:8080/java-ee-8-getting-started/getting-started/hello?name=john, which is the link on the index.html page. Any ideas why it’s not working?

Back to top button