Module 3 Web Component

Transcription

1 Module 3 Component Model Objectives Describe the role of web components in a Java EE application Define the HTTP request-response model Compare Java servlets and JSP components Describe the basic session management strategies Manage thread safety issues in web components Describe the purpose of web-tier design patterns 69 Ω Omega Ω 1

2 Role of Components in a Java EE Application -centric Java EE application architecture: EJB component-centric Java EE application architecture: 70 Ω Omega Ω HTTP Request-Response Model 71 Ω Omega Ω 2

3 The GET and POST Requests 72 Ω Omega Ω Form Data HTML snippet: <FORM ACTION= form_test METHOD= POST > <INPUT NAME= input1 SIZE= 20 /> <INPUT TYPE= SUBMIT VALUE= OK /> </FORM> Browser form: Browser request: POST /bank/form_test HTTP/ request headers... input1=this+is+a+test 73 Ω Omega Ω 3

4 Content Type and the Response Header The server response includes a Content-Type header that contains MIME type values including but not limited to: text/html text/xml image/jpeg Examples of additional response headers include: Content-Encoding Content-Length Cache-Control 74 Ω Omega Ω Comparison of Servlets and JSP Components 75 Ω Omega Ω 4

5 Life Cycle of a Component 76 Ω Omega Ω The service Method The web container calls the service method once for each incoming request. The service method then typically completes the following operations: Validates any form data Updates the application s data model Collects data from the model to be rendered Renders the data in HTML or passes the request and the data to another component responsible for rendering them 77 Ω Omega Ω 5

6 Servlet and JSP Component Examples The examples on the following slides illustrate the similarities and differences between servlets and JSP components. Servlet example JSP component example Servlet and JSP component collaboration Run-time behavior of servlets and JSP components context root and alias mapping 78 Ω Omega Ω Servlet Example 79 Ω Omega Ω 6

7 JSP Component Example The following code generates the same output as the preceding servlet example: 80 Ω Omega Ω Servlet and JSP Component Collaboration Most modern web applications use servlets and JSP components in collaboration. Their capabilities are similar, but they are expressed differently.: 81 Ω Omega Ω 7

8 Run-Time Behavior of Servlets and JSP Components Because JSP components are translated into servlets, JSP components and servlets share run-time behaviors: Life cycle and container management API and container services Client session access Both can be entered on multiple threads concurrently and must be implemented accordingly. 82 Ω Omega Ω Component Thread Model int x; public void doget(){ 83 Ω Omega Ω 8

9 Implications for the Developer Because the web container enters the service method on multiple concurrent threads to support multiple simultaneous requests, the developer must ensure that web components are thread-safe: Use instance variables cautiously Use class variables very cautiously Provide access to external resources cautiously Use synchronization constructs to denote critical sections: synchronized (this) { } // This section is only entered by 1 thread at a time 84 Ω Omega Ω Context Root and Alias Mapping Servlets and JSP components are packaged into a web application. Static content, such as HTML or images, is included. A web application URI has the following form: The context root maps to a web application In the deployment descriptor a url pattern is specified that maps from a JSP or Servlet resource to a url: 85 Ω Omega Ω 9

10 Session Management The HTTP protocol is stateless. Conversational state might be stored on either the browser or the server: The Java EE model provides a simple mechanism for storing conversational state on the server. 86 Ω Omega Ω Problems With -Tier Development The complexities of web-based user interface development include: Addressing HTTP s stateless request-response sequence Avoiding the creation of large numbers of servlets and JSP components that handle different types of requests Using JSP components and servlets effectively 87 Ω Omega Ω 10

11 Model 1 and Model 2 Architectures Two design strategies are involved in using JSP components in the web tier: Model 1 architecture: JSP components handle request processing through <jsp:usebean> classes, the JSTL, and custom tags. JSP components render data that is retrieved from the business logic tier. Model 2 architecture: Servlets handle request processing, interact with the business logic, and collect data for display. JSP components render the data for display. 88 Ω Omega Ω Traditional MVC Architecture 89 Ω Omega Ω 11

12 Model 2 Architecture as MVC 90 Ω Omega Ω MVC in the Java EE Platform The MVC paradigm divides application logic into three roles: Controller View Model When the application includes EJB components When there are no EJB components 91 Ω Omega Ω 12

13 Using -Tier Design Patterns The web-tier developer should work with specific design patterns that realize the broad, architectural paradigms of MVC and Model 2 architecture. Of the many available patterns, consider these three specific patterns, which can be used in combination: Service-to-Worker Dispatcher View Business Delegate 92 Ω Omega Ω Service-to-Worker and Dispatcher View Patterns 93 Ω Omega Ω 13

14 -Tier Design Framework Construction The Service-to-Worker and Dispatcher View patterns provide generic functionality that can be extracted to form a design framework. Each request is handled in the same generic way, with variations for the specific needs of the application. The controller element is the most generic, allowing reuse in different applications. The controller s functionality can be expressed declaratively, rather than in code. 94 Ω Omega Ω Some Available -Tier Frameworks Commonly used frameworks include: Struts JavaServer Faces technology 95 Ω Omega Ω 14

15 Business Delegate Pattern 96 Ω Omega Ω 15