Developing RESTful Services with REST/JAX-RS

Developing RESTful Services with REST/JAX-RS

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.

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
• Expanded 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
• Bind request inputs to method parameters, including path parameters, query parameters, and headers
• Exchange business data by communicating in HTTP entities in both XML and JSON format
• 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
• Write browser clients using Ajax-JavaScript
• 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

Outline

1. Web Services Overview
2. Definition
3. Legacy Systems
4. Benefits of Web Services
5. Architecture
6. Standards and Portability
7. XML and Related Standards
8. JSON
9. HTTP
10. SOAP-Based Services
11. Overview
12. SOAP Messages, Requests, and Responses
13. WSDL
14. Java APIs and Programming Models
15. Introduction to REST
16. Overview and Principles
17. REST Characteristics
18. Resources and Operations
19. REST Principles
20. Requests and Responses
21. REST APIs
22. URI Templates
23. GET, POST, PUT, DELETE
24. Safe and Idempotent Methods
25. Comparison of REST and SOAP
26. Introduction to JAX-RS
27. APIs and Implementations
28. JAX-RS Overview, Annotations
29. JAX-RS Implementations
30. Runtime Environment
31. Application Server, Servlet-Only Container
32. Architectural and Implementation Perspectives
33. Configuring the Application
34. Applications, Resources, and Providers
35. JAX-RS Applications
36. Resource Classes and @Path
37. Provider Classes and @Provider
38. Default Lifecycles
39. The Application Class and rest-path
40. Ajax-JavaScript Clients
41. Overview
42. Classic vs. Ajax Interactions
43. Working with Ajax-JavaScript
44. Resources and Requests
45. Resources and Subresources
46. Root Resource Classes, Resource Methods, Subresource Methods
47. @GET, @POST, @PUT, @DELETE
48. Subresource Locators
49. Naming Conventions and Rules
50. Dispatching Requests to Methods
51. Binding Request Data
52. Request Data Injection and Conversion
53. Default Values
54. Fields vs. Method Parameters
55. Context-Based Injection
56. Injection via @Context
57. Context-Injectable Types
58. Context Injection from the Web Container
59. Fields vs. Method Parameters
60. HTTP Entities
61. Complex Content and Entities
62. Working with Complex Content
63. @Consumes and @Produces
64. Content Negotiation
65. Standard Entity Providers
66. Working with JSON
67. Returning Data as JSON
68. Working with JSON in JavaScript
69. Processing JSON Responses
70. Working with XML
71. JAXB and Mapping to XML
72. Returning Data as XML
73. Working with XML on the Client
74. Customizing Content, Custom Media Types
75. Working with Collections
76. XML vs. JSON
77. Responses
78. Response Class
79. Return Types and HTTP Response Codes
80. Appropriate Responses for HTTP Methods
81. Choosing the Right Response
82. Error Handling
83. Exception Mappers
84. WebApplicationException
85. Response vs. Thrown Exception
86. Error Responses
87. Subresource Locators
88. Motivation and Uses
89. Locating the Locator
90. Initializing the Subresource
91. Binary Content
92. File, InputStream, StreamingOutput
93. Using StreamingOutput
94. Java Client API
95. Java Client - Options and Ingredients
96. Building and Sending the Request
97. Consuming the Response
98. Options for the Response Data
99. Asynchronous Requests
100. Integration with Java EE
101. Integration with EJB
102. CDI - Contexts and Dependency Injection
103. Activation, Scopes, and JAX-RS Lifecycles
104. Injection in CDI-Enabled JAX-RS Applications
105. Enhanced Java EE Lifecycle
106. Security
107. Java EE Security Overview
108. Security Requirements in JAX-RS
109. Declarative, Role-Based Security
110. Security Constraints
111. Annotation-Based Security
112. Authentication
113. Configuration
114. Authentication Models: Basic, Digest, Client-Cert
115. Programmatic Security
116. SecurityContext
117. Client Security
118. HTTPS

Required Prerequisites

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

Useful Prerequisites

Familiarity with Ajax, JavaScript, and JSON.

‍