跳至主要内容

Getting started with Java EE 8 MVC

Getting started with Java EE 8 MVC

MVC is a new specification introduced in the upcoming Java EE 8.
It is based on the existing JAXRS.
At the moment I wrote down these posts, most of Java EE 8 specficitaions are still in the early disscussion stage, and MVC 1.0 is also not finalized, maybe some changes are included in future. I will update the Wiki pages and codes aglined with final Java EE 8 specficitaions when it is released.
I will use the latest Java 8, Glassfish 4.1.1, and NetBeans IDE for these posts.

Prequisition

  • Oracle JDK 8 or OpenJDK 8
    Oracle Java 8 is required, go to Oracle Java website to download it and install into your system.
    Optionally, you can set JAVA_HOME environment variable and add <JDK installation dir>/bin in your PATH environment variable.
  • The latest Apache Maven
    Download the latest Apache Maven from http://maven.apache.org, and uncompress it into your local system.
    Optionally, you can set M2_HOME environment varible, and also do not forget to append <Maven Installation dir>/bin your PATH environment variable.
  • NetBeans IDE
    Download the latest NetBeans IDE from http://www.netbeans.org, and installed it into your local disk.
  • Glassfish Server
    Download the latest Glassfish from Glassfish official website. Currently the latest GA version is 4.1.1. Extracted it into your local disk.
NOTE: You can download the JDK and NetBeans bundle from Oracle website instead of installing JDK and NetBeans IDE respectively.
After you installed all of these, start NetBeans IDE, add Glassfish into Service tab in NetBeans IDE.

The Sample application

To demonstrate the basic usage of MVC spection, I will port the task board sample which I have implemented in the Spring4 Sandbox to demonstrate Spring MVC.
Simply, it includes the following features.
  1. List tasks by status, display the tasks in 3 columns(like a simple kanban).
  2. Create a new task.
  3. Edit and update task.
  4. Update task stauts(move to different columns in the task list).
  5. Delete task if it is done.

Create a project skeleton

First of first, you should create a simple project skeleton as start point.
If you are using NetBeans IDE, it is easy to create a Maven based Java EE 7 web project in IDE directly, and add the registered Glassfish as runtime server.
It should include Java EE 7 web artifact as the dependency.
<dependency>
    <groupId>javax</groupId>
    <artifactId>javaee-web-api</artifactId>
    <version>7.0</version>
    <scope>provided</scope>
</dependency>   
Add additional MVC api and the implemnetation dependencies.
<dependency>
    <groupId>javax.mvc</groupId>
    <artifactId>javax.mvc-api</artifactId>
    <version>1.0-edr2</version>
</dependency>
<dependency>
    <groupId>org.glassfish.ozark</groupId>
    <artifactId>ozark</artifactId>
    <version>1.0.0-m02</version>
    <scope>runtime</scope>
</dependency>
ozark is the default reference implemnetation of MVC 1.0 specificaiton, which will shipped with Glassfish 5. Currently it is still under active development, what we are using here may be changed in the future.
Here we used Glassfish 4.1.1 as target runtime, so you should include them in the deployment package.
When Glassfish 5 is ready for Java EE 8, these two dependencies can be excluded and removed from POM.

Declare the MVC application

MVC does not reinvent the wheel, it reuses the effort of JAXRS specificaiton.
Similar with activiating JAXRS application, You can declare a custom Application as our MVC application entry.
@ApplicationPath("mvc")
public class MvcConfig extends Application {

    @Override
    public Set<Class<?>> getClasses() {
        return Collections.singleton(TaskController.class);
    }
}
TaskController is a controller, it acts as the C in MVC pattern.

Controller

MVC uses a @Controller annotation to declare a JAXES resource as Controller.
@Path("tasks")
@Controller
public class TaskController {

    @GET
    @View("tasks.jspx")
    public void allTasks() {
        log.log(Level.INFO, "fetching all tasks");

        List<Task> todotasks = taskRepository.findByStatus(Task.Status.TODO);
        List<Task> doingtasks = taskRepository.findByStatus(Task.Status.DOING);
        List<Task> donetasks = taskRepository.findByStatus(Task.Status.DONE);

        log.log(Level.INFO, "got all tasks: todotasks@{0}, doingtasks@{1}, donetasks@{2}", new Object[]{todotasks.size(), doingtasks.size(), donetasks.size()});

        models.put("todotasks", todotasks);
        models.put("doingtasks", doingtasks);
        models.put("donetasks", donetasks);

    }
}
@View annotation indicates the view(eg. JSP pages) a void method will return.

Model

Models is a contrainer to hold the model datas that will be transfered to the view.

View

Have a look at the tasks.jspx file, I just copied some code snippets here, please checkout the source codes for details.
<div class="col-md-4 col-xs-12">
    <div class="panel panel-default">
        <!-- Default panel contents -->
        <div class="panel-heading">
            <span class="glyphicon glyphicon-list-alt" aria-hidden="true"><jsp:text /></span>
            TODO
        </div>
        <div class="panel-body">
            <p>Tasks newly added in the backlog.</p>
        </div>

        <!-- List group -->
        <c:if test="${not empty todotasks}">
            <ul id="todotasks" class="list-group">
                <c:forEach var="task" begin="0" items="${todotasks}">
                    <li class="list-group-item">
                        <h4>
                            <span>#${task.id} ${task.name}</span> <span class="pull-right">
                                <c:url var="taskUrl" value="tasks/${task.id}" /> <c:url
                                    var="taskEditUrl" value="tasks/${task.id}/edit" /> <a
                                    href="${taskUrl}"> <span class="glyphicon glyphicon-file"
                                                         aria-hidden="true"><jsp:text /></span>
                                </a> <a href="${taskEditUrl}"> <span
                                        class="glyphicon glyphicon-pencil" aria-hidden="true"><jsp:text /></span>
                                </a>
                            </span>
                        </h4>
                        <p>${task.description}</p>
                        <p>
                            <c:url var="markDoingUrl"
                                   value="/mvc/tasks/${task.id}/status" />
                        <form action="${markDoingUrl}" method="post">
                            <input type="hidden" name="_method" value="PUT"><jsp:text /></input>
                            <input type="hidden" name="status" value="DOING"><jsp:text /></input>
                            <button type="submit" class="btn btn-sm btn-primary">
                                <span class="glyphicon glyphicon-play" aria-hidden="true"><jsp:text /></span>
                                START
                            </button>
                        </form>
                        </p>
                    </li>
                </c:forEach>
            </ul>
        </c:if>
    </div>
</div>
No surprise, just pure JSP files, I used the JSP xml form in this sample.
By default the views should be put in the /WEB-INF/views folder in projects.
In this example, when you send a GET request to /ee8-mvc/mvc/tasks, the allTasks() method will handle this request, then find data(tasks by status here) from database, and put the query results into a Models container, in the view pages the model data can be accessed via el directly.
The path(/ee8-mvc/mvc/tasks) is the combination of context path, mvc application path, and controller path.

Source codes

  1. Clone the codes from my github.com account.
    https://github.com/hantsy/ee8-sandbox/
  2. Open the mvc project in NetBeans IDE.
  3. Run it on Glassfish server.
  4. After it is deployed and running on the Glassfish application server, navigate http://localhost:8080/ee8-mvc/mvc/tasks in your favorite browser.
    https://github.com/hantsy/ee8-sandbox/wiki/mvc-tasks.png

评论

此博客中的热门博文

Build a Reactive application with Angular 5 and Spring Boot 2.0

I have created a post to describe Reactive programming supports in Spring 5 and its subprojects, all codes of this article are updated the latest Spring 5 RELEASE, check spring-reactive-sample under my Github account.
In this post, I will create a simple blog system, including:
A user can sign in and sign out.An authenticated user can create a post.An authenticated user can update a post.Only the user who has ADMIN role can delete a post.All users(including anonymous users) can view post list and post details.An authenticated user can add his comments to a certain post. The backend will be built with the latest Spring 5 reactive stack, including:
Spring Boot 2.0, at the moment the latest version is 2.0.0.M7Spring Data MongoDB supports reactive operations for MongoDBSpring Session adds reactive support for WebSessionSpring Security 5 aligns with Spring 5 reactive stack The frontend is an Angular based SPA and it will be generated by Angular CLI.
The source code is hosted on Github, …

Activating CDI in JSF 2.3

Activating CDI in JSF 2.3 When I upgraded my Java EE 7 sample to the newest Java EE 8, the first thing confused me is the CDI beans are not recoganized in Facelects template in a JSF 2.3 based web applicaiton, which is working in the development version, but in the final release version, they are always resolved as null. I filed an issue on Mojarra and discussed it with the developers from communities and the JSF experts.
According to the content of README, In a JSF 2.3 application, to activate CDI support, declaring a 2.3 versioned faces-config.xml and adding javax.faces.ENABLE_CDI_RESOLVER_CHAIN in web.xml is not enough, you have to declare @FacesConfig annotated class to enable CDI.
Here is the steps I created a workable JSF 2.3 applicatoin in Java EE 8.
Create a Java web application, this can be done easily by NetBeans IDE, or generated by Maven archetype, for exmaple.
$ mvn archetype:generate -DgroupId=com.example -DartifactId=demo -DarchetypeArtifactId=maven-archetype-we…

JSF 2.3:Websocket support

Websocket support One of the most attractive features is JSF 2.3 added native websocket support, it means you can write real-time applications with JSF and no need extra effort.
To enable websocket support, you have to add javax.faces.ENABLE_WEBSOCKET_ENDPOINT in web.xml.
<context-param> <param-name>javax.faces.ENABLE_WEBSOCKET_ENDPOINT</param-name> <param-value>true</param-value> </context-param> Hello Websocket Let's start with a simple example.
@ViewScoped@Named("helloBean") publicclassHelloBeanimplementsSerializable { privatestaticfinalLoggerLOG=Logger.getLogger(HelloBean.class.getName()); @Inject@PushPushContext helloChannel; String message; publicvoidsendMessage() { LOG.log(Level.INFO, "send push message"); this.sendPushMessage("hello"); } privatevoidsendPushMessage(Objectmessage) { helloChannel.send(""+ message +" at &…