Programming RESTful Services with REST/JAX-RS

Programming RESTful Services with REST/JAX-RS

Course Length: 3 days
Delivery Methods: Multiple delivery options
Course Overview

This course provides in-depth coverage of REST principles and building RESTful services using the JAX-RS 2.0 API. It includes a brief overview of SOAP-based services and WSDL to provide a contrast to RESTful services.

To really understand REST, we need to remind (teach) students about the full capabilities of HTTP, since RESTful service design is centered on the innate principles and capabilities of the HTTP protocol. Stated differently, RESTful services should use HTTP the way it was originally intended, not just as GET/POST plumbing for request/response data. You will emerge from the course with a full understanding of the HTTP protocol and its vision of the “original web,” and how these ideas are implemented in RESTful applications.

We’ll show you how to handle the most common types of request input, culminating in the transmission of HTTP entities in both XML and JSON format, in line with the original intention of HTTP. You’ll also learn how to create appropriate responses given a variety of inputs and conditions, according to the guidelines and principles in the HTTP standard.

On the client side, we look at Ajax-JavaScript clients, as well as standalone Java clients using the JAX-RS 2.0 Client API.

Your daily personal use of the web is increasingly RESTful, and this course will show you how to expose your backend business systems using REST and the innate API and capabilities of HTTP. We also take cues from the masters such as Google, examining some of their public services and using them as a backdrop in building our own.

The course is very hands-on with frequent labs, in which the student can see these ideas implemented in software.

All labs are done with the Eclipse IDE Java EE version and the WildFly Application Server, and the lab instructions include detailed directions for using them. Other IDEs and servers available on request.

Course Benefits
  • Understand the purpose and role of web services in general, and how they are architected to expose business systems and processes over the web.
  • Understand the concepts and principles of REST and HTTP applications.
  • Expande your knowledge of HTTP, including its full set of methods and their intended uses, important headers, response codes, and content types.
  • Understand REST APIs, including resource identifiers and the URI namespace, resources and subresources, and WADL.
  • Understand configuration, deployment, and the runtime environment, including per-request and singleton objects, options for dependency injection, etc.
  • Understand how HTTP requests get dispatched to service methods.
  • Understand content negotiation and the importance of Accept and Content-Type headers, and how they impact method dispatching.
  • Learn to bind request inputs to method parameters, including path parameters, query parameters, and headers.
  • Learn to exchange business data by communicating in HTTP entities in both XML and JSON format.
  • Learn to handle errors using Java exceptions and appropriate HTTP response codes.
  • Learn how to integrate JAX-RS services with other Java EE technologies like servlets, EJB, and CDI, and how JAX-RS fits into the larger Java EE landscape.
  • Learn to write browser clients using Ajax-JavaScript.
  • Learn to write Java clients using the JAX-RS 2.0 Client API, including standalone clients and server-side components invoking remote services.
  • Learn how to secure RESTful resources.
Available Delivery Methods
Public Class
Public expert-led online training from the convenience of your home, office or anywhere with an internet connection. Guaranteed to run .
Private Class
Private classes are delivered for groups at your offices or a location of your choice.
Course Outline
  1. Java Overview
    1. Language and Platform Features
    2. A Simple Java Program
    3. The Java Release Cycle
    4. Program Lifecycle
    5. The Java SE Development Kit (JDK)
    6. LABS:
      1. Hello World: A Simple Application
  2. Class and Object Basics
    1. The Object Model and Object-Oriented Programming
    2. Classes, References, and Instantiation
    3. Adding Data to a Class Definition
    4. Adding Methods (Behavior)
    5. LABS:
      1. Exploring Types and Object Instances
      2. Introducing your IDE
      3. Writing and Using a Class Definition with Fields and Methods
  3. More on Classes and Objects
    1. More about Methods
    2. Encapsulation and Access Control, public and private Access
    3. Constructors and Initialization
    4. static Members of a Class
    5. LABS:
      1. Accessor Methods
      2. Encapsulation / Access Protection
      3. Writing and Using Constructors
      4. Static Members
  4. Flow of Control
    1. Branching: if, if-else, switch
    2. Iteration: while, do-while, for, break, continue
    3. LABS:
      1. Data Validation
  5. More about Classes and Objects
    1. Type-safe Enums
    2. Wrapper Classes
    3. Java 8+ Date/Time Support
    4. Working with References
    5. Formatted Output
    6. LABS:
      1. Using enums
      2. Working with Dates and Times
      3. Using the Debugger
  6. Strings, Arrays, and Dates/Times
    1. String, StringBuffer, StringBuilder
    2. Arrays, Primitive Arrays, Arrays of Reference Types
    3. varargs
    4. LABS:
      1. Using Strings and Arrays
  7. Packages and Modules
    1. Package Overview - Using Packages to Organize Code
    2. Creating Packages, package Statement, Required Directory Structure
    3. import statements
    4. Classpath
    5. Java Modules Overview
    6. Defining Modules, Requires, and Exports
    7. Module Path and Classpath - Differences and Coexistence
    8. LABS:
      1. Using Packages
      2. Using Java Modules
  8. Composition and Inheritance
    1. Using Composition to Deal With Complexity
    2. Composition/HAS-A, Delegation
    3. Using Inheritance to share commonality
    4. IS-A, extends Inheriting Features
    5. Constructor Issues
    6. Overriding Methods, @Override, Using Polymorphism
    7. Abstract Classes
    8. LABS:
      1. Working with Composition
      2. Using Inheritance
      3. Polymorphism
      4. Polymorphism
  9. Interfaces
    1. Defining and Implementing Interfaces
    2. Using Interfaces
    3. Default Methods and static Methods
    4. LABS:
      1. Using Interfaces to Remove Implementation Dependencies
      2. Using Default and Static Methods
  10. Exceptions
    1. Exceptions and the Exception Hierarchy
    2. Throwing Exceptions and Checked Exceptions
    3. try and catch
    4. Handling Exceptions
    5. try and catch
    6. Program Flow with Exceptions
    7. Multicatch, finally, try-with-resources
    8. LABS:
      1. Throwing Exceptions
      2. Checked Exceptions
  11. Java Collections and Generics
    1. The Collections Framework and its API
    2. Collections and Java Generics
    3. Collection, List, Set, Map
    4. Autoboxing
    5. Collections of Object (non-generic)
    6. Using ArrayList, HashSet, and HashMap
    7. for-each Loop
    8. Processing Items With an Iterator
    9. More About Generics
    10. LABS:
      1. Using Collections and Generics
  12. Database Access with JDBC and JPA
    1. JDBC Overview
    2. JDBC Defined Types
    3. Example of JBDC Usage
    4. JPA Overview
    5. JPA Architecture and Programming View
    6. Mapping Entity Classes with Annotations
    7. Persistence Unit, EntityManagerFactory, and EntityManager
    8. Working with JPA (Find by primary key and inserts)
    9. LABS:
      1. Mapping an Entity Class
      2. Using JPA
      3. Insert/Query Demo
  13. I/O Streams (Optional)
    1. I/O Streams Overview
    2. Readers and Writers
    3. Exception Handling
    4. Byte Streams
    5. Working with Files
    6. NIO, Paths, Files
    7. LABS:
      1. Reading and Writing Files
      2. Using Byte Streams (Optional)
  14. Additional Language Features (Optional)
    1. Functional Interfaces and Lambda Expressions
    2. Switch Expressions
    3. Other Java Features
    4. LABS:
      1. Working with Lambdas (Demo)
Class Materials

Each student will receive a comprehensive set of materials, including course notes and all the class examples.

Class Prerequisites

Experience in the following is required for this Java class:

  • Attendees must be experienced in Java and ideally will be somewhat familiar with XML, Java web applications, and other Java EE standards.

Experience in the following would be useful for this Java class:

  • Familiarity with Ajax, JavaScript, and JSON.
Prerequisite Courses

Courses that can help you meet these prerequisites:

Register for a Live Class
$1,425.00
Please select a class.
Request a Private Class
  • Private Class for your Team
  • Online or On-location
  • Customizable
  • Expert Instructors
Request Pricing