Mobile Programming - Lecture 14

Cay S. Horstmann

REST

• Client-server interface
• Classic model: Remote procedure call (SOAP)
• REST is stateless, cacheable
• REST verbs: GET, POST, PUT, DELETE
• REST API uses resource IDs that are revealed by the application (“hypertext model”)
• REST URLs often look like http://api.fred.com/query/param

JAX-RS

• Lets you build REST apps in Java
• Needs a Java app server (e.g. GlassFish) or web profile bits and pieces
• Can convert between Java objects/XML/JSON (via JAXB)

Hello, World!

import javax.ws.rs.*;
import javax.ws.rs.core.*;

@Path("/hello")
public class HelloService {
   @GET
   @Path("/{name}")
   public Response getText(@PathParam("name") String name) {
      String output = "Hello " + name + "\n";
      return Response.status(200).entity(output).build();
   }
}
  

Java EE for Elvis

• Standard Java approach for web applications
• Greatly simplified in EE5, EE6
• Robust, scalable server technology (transactions, clustering, etc. without additional programming)
• Why Elvis? Google for Mort Elvis Einstein

Java EE Architecture

• User interface: JSF pages, HTML 5, mobile device
• Business logic: Session beans
• Persistence: Entity beans
• Bean = class with default constructor and properties (getters/setters)

Java Persistence Architecture (JPA)

• Stores Java entity classes in SQL databases
• Annotate class with @Entity
• Supply ID field and annotate with @Id @GeneratedValue
• Annotate relationships with @OneToMany etc.

  import javax.persistence.*;
  @Entity public class Question implements Serializable {
      @Id @GeneratedValue private int id;
      private String text;
      @OneToMany private Set<Choice> choices;
      @OneToOne private Choice answer;
      public Question() {} // No-arg constructor is required          
      ...
  }

• Stored in a table with columns ID, TEXT, ANSWER_ID
• QUESTION_CHOICE table associates IDs of question and choice

Entity Manager

• Persistence context = set of managed entities
• Entity manager = object that manages persistence context (has methods persist, find, createQuery, ...)
• JPQL = object-oriented persistence query language

  EntityManager em = ...; // see next slide
  Query q = em.createQuery("SELECT x FROM Question q WHERE q.id = :id")
      .setParameter("id", id);
  Question p = (Question) q.getSingleResult(); // Also fetches choices (maybe lazily)

• Here are more sample JPA queries

Session Beans

• Entity manager can only be accessed by “session beans”
• Stateless session bean has “do and forget” methods; similar to a class with only static methods
• Methods are automatically transactional (serialized, roll back on errors)
• Entity manager injected into session bean

  @Stateless
  public class UserSB {
      @PersistenceContext private EntityManager em;
      ...
  }

• “injected” means that the field is set by the container when the bean is constructed

Lab

• Bring your laptop to each class
• You will work with a buddy
• One of you writes code, the other types up answers
• Switch roles each lab (not each day)
• Submit lab work to Piazza

Hello, World

• Run path/to/glassfish4/bin/asadmin start-domain
• Point your web browser to http://localhost:8080. What happens?
• In your work directory for this course, run mkdir -p lab14/WEB-INF/classes
• Place the HelloService class into the lab14 directory
• Also place the following class there:

  import java.util.*;
  import javax.ws.rs.*;
  import javax.ws.rs.core.*;
  
  @ApplicationPath("/rest")
  public class AppConfig extends Application {
     public Set<Class<?>> getClasses() {
        return new java.util.HashSet<Class<?>>(Arrays.asList(HelloService.class));
     }
  }
          

• Run javac -d WEB-INF/classes -cp .:path/to/glassfish4/glassfish/modules/\* *.java.
• Run jar cvfM path/to/glassfish4/glassfish/domains/domain1/autodeploy/myapp.war WEB-INF
• Point your browser to http://localhost:8080/myapp/rest/hello/World. What happens?
• Why 8080? Why myapp? Why rest? Why hello?
• What happens with World?

Serving Questions

• Copy this Question class to the lab14 directory, and remove the package statement.
• Add a QuestionService class

  import java.util.Scanner;
  import javax.ws.rs.*;
  import javax.ws.rs.core.*;
  
  @Path("/question")
  public class QuestionService {
      @GET
      @Path("/{id}")
      @Produces("text/plain")
      public Response getQuestion(@PathParam("id") int id) {
          // Ignoring id for now
          Question q = new Question();
          q.read(new Scanner("What was the best-selling smartphone OS in 2006?\nAndroid\n*Blackberry\niOS\nWindows Mobile\n"));
  
          return Response.status(200).entity(q.toString()).build();
      }
  }

• Rebuild and point your browser to http://localhost:8080/myapp/rest/question/1. What happens?

Producing XML and JSON

• Add the following highlighted parts to the Question class:

  import javax.xml.bind.annotation.*; 
  
  @XmlRootElement
  public class Question implements Serializable {
      @XmlElement
      private String text;
      @XmlElement
      private List<String> choices = new ArrayList<String>();
      @XmlElement
      private String answer;
      ...
  }
  

• In QuestionService, change text/plain to application/xml and q.toString() to q. Rebuild and point your browser to http://localhost:8080/myapp/rest/question/1. What happens?
• Now change application/xml to application/json and repeat. What happens?
• Are you impressed?

The Entities

• A quiz has questions. Questions have choices.
• 
• Basic Java classes: Question Choice. (We skip Quiz for now)
• Turn these into entity classes. Hint: @Entity, @OneToMany, @OneToOne. Remember to add an id field to each class. Also remember that entity classes need a default constructor.

Initializing the Data

• Normally, this part is done differently. Here, we just do it ad-hoc and in a rather un-RESTful way.
• Start GlassFish and run

  path/to/glassfish4/bin/asadmin start-database

• Build a WAR file with
  • QuestionService
  • Your entity classes
  • The AppConfig from the previous step
  • persistence.xml in WEB-INF/classes/META-INF/persistence.xml
• After compiling and deploying, point your browser to http://localhost:8080/myapp/rest/question/init
• What happens?
• Write down those numbers. You'll need them later.

Optional—Spying on the Database

• This slide is optional. Skip it if you are short on time.
• Make a file ij.properties with this contents:

  ij.driver=org.apache.derby.jdbc.ClientDriver
  ij.protocol=jdbc:derby://localhost:1527/
  ij.database=sun-appserv-samples

  Run the command

  java -jar path/to/glassfish4/javadb/lib/derbyrun.jar ij -p ij.properties

  Then run the commands

  select * from question;
  select * from choice;        
  select * from question_choice;

  Explain the role of the question_choice table.
• exit; gets you out of ij.

Client Queries

• Complete the JAX-RS method that lets us query for a question with a given ID as http://localhost:8080/myapp/rest/question/129, where the last part is the question id, revealed by the /init command. Make a JPQL query and return the toString of the result.
• Compile and deploy, then point your browser to the URL given above, where you use the ID number of the question that you got from two slides ago.
• What happens?
• Optional, if you have extra time: Change your program so that you get the question in JSON format. How did you do that? (Hint: @XmlRootElement, @XmlElement, @Produces)