First pass at webapp (#171)

Signed-off-by: Guillermo González de Agüero <z06.guillermo@gmail.com>

src/main/jbake/content/webapp.adoc

@@ -20,9 +20,9 @@ The following topics are addressed here:
 
 * link:webapp001.html#GEYSJ[Web Applications]
 * link:webapp002.html#BNADU[Web Application Lifecycle]
-* link:webapp003.html#BNADX[A Web Module That Uses JavaServer Faces
+* link:webapp003.html#BNADX[A Web Module That Uses Jakarta Server Faces
 Technology: The hello1 Example]
-* link:webapp004.html#BNAEO[A Web Module That Uses Java Servlet
+* link:webapp004.html#BNAEO[A Web Module That Uses Jakarta Servlet
 Technology: The hello2 Example]
 * link:webapp005.html#CHDHGJIA[Configuring Web Applications]
 * link:webapp006.html#BNAFC[Further Information about Web Applications]

src/main/jbake/content/webapp001.adoc

@@ -19,24 +19,24 @@ Web applications are of the following types:
 generates interactive web pages containing various types of markup
 language (HTML, XHTML, XML, and so on) and dynamic content in response
 to requests. Development of presentation-oriented web applications is
-covered in link:jsf-intro.html#BNAPH[Chapter 7, "JavaServer Faces
-Technology,"] through link:servlets.html#BNAFD[Chapter 18, "Java Servlet
+covered in link:jsf-intro.html#BNAPH[Chapter 7, "Jakarta Server Faces
+Technology,"] through link:servlets.html#BNAFD[Chapter 18, "Jakarta Servlet
 Technology."]
 * Service-oriented: A service-oriented web application implements the
 endpoint of a web service. Presentation-oriented applications are often
 clients of service-oriented web applications. Development of
 service-oriented web applications is covered in
 link:jaxws.html#BNAYL[Chapter 31, "Building Web Services with JAX-WS,"]
 and link:jaxrs.html#GIEPU[Chapter 32, "Building RESTful Web Services with
-JAX-RS,"] in link:partwebsvcs.html#BNAYK[Part III, "Web Services."]
+Jakarta RESTful Web Services,"] in link:partwebsvcs.html#BNAYK[Part III, "Web Services."]
 
 In the Jakarta EE platform, web components provide the dynamic extension
-capabilities for a web server. Web components can be Java servlets, web
-pages implemented with JavaServer Faces technology, web service
-endpoints, or JSP pages. link:#BNADS[Figure 6-1] illustrates the
+capabilities for a web server. Web components can be Jakarta servlets, web
+pages implemented with Jakarta Server Faces technology, web service
+endpoints, or Jakarta Server pages. link:#BNADS[Figure 6-1] illustrates the
 interaction between a web client and a web application that uses a
 servlet. The client sends an HTTP request to the web server. A web
-server that implements Java Servlet and JavaServer Pages technology
+server that implements Jakarta Servlet and Jakarta Server Pages technology
 converts the request into an `HTTPServletRequest` object. This object is
 delivered to a web component, which can interact with JavaBeans
 components or a database to generate dynamic content. The web component
@@ -47,21 +47,21 @@ HTTP response and returns it to the client.
 
 [[BNADS]]
 
-.*Figure 6-1 Java Web Application Request Handling*
+.*Figure 6-1 Jakarta Web Application Request Handling*
 image:img/jakartaeett_dt_013.png[
 "Diagram of web application request handling. Clients and servlets
 communicate using HttpServletRequest and HttpServletResponse."]
 
 Servlets are Java programming language classes that dynamically process
-requests and construct responses. Java technologies, such as JavaServer
+requests and construct responses. Java technologies, such as Jakarta Server
 Faces and Facelets, are used for building interactive web applications.
 (Frameworks can also be used for this purpose.) Although servlets and
-JavaServer Faces and Facelets pages can be used to accomplish similar
+Jakarta Server Faces and Facelets pages can be used to accomplish similar
 things, each has its own strengths. Servlets are best suited for
 service-oriented applications (web service endpoints can be implemented
 as servlets) and the control functions of a presentation-oriented
 application, such as dispatching requests and handling nontextual data.
-JavaServer Faces and Facelets pages are more appropriate for generating
+Jakarta Server Faces and Facelets pages are more appropriate for generating
 text-based markup, such as XHTML, and are generally used for
 presentation-oriented applications.
 
@@ -76,7 +76,7 @@ application is installed, or deployed, to the web container. The
 configuration information can be specified using Jakarta EE annotations or
 can be maintained in a text file in XML format called a web application
 deployment descriptor (DD). A web application DD must conform to the
-schema described in the Java Servlet specification.
+schema described in the Jakarta Servlet specification.
 
 This chapter gives a brief overview of the activities involved in
 developing web applications. First, it summarizes the web application

src/main/jbake/content/webapp002.adoc

@@ -41,7 +41,7 @@ The Hello application contains two web components that generate the
 greeting and the response. This chapter discusses the following simple
 applications:
 
-* `hello1`, a JavaServer Faces technology–based application that uses
+* `hello1`, a Jakarta Server Faces technology–based application that uses
 two XHTML pages and a managed bean
 * `hello2`, a servlet-based web application in which the components are
 implemented by two servlet classes

src/main/jbake/content/webapp003.adoc

@@ -1,18 +1,18 @@
 type=page
 status=published
-title=A Web Module That Uses JavaServer Faces Technology: The hello1 Example
+title=A Web Module That Uses Jakarta Server Faces Technology: The hello1 Example
 next=webapp004.html
 prev=webapp002.html
 ~~~~~~
-= A Web Module That Uses JavaServer Faces Technology: The hello1 Example
+= A Web Module That Uses Jakarta Server Faces Technology: The hello1 Example
 
 
 [[BNADX]][[a-web-module-that-uses-javaserver-faces-technology-the-hello1-example]]
 
-A Web Module That Uses JavaServer Faces Technology: The hello1 Example
-----------------------------------------------------------------------
+A Web Module That Uses Jakarta Server Faces Technology: The hello1 Example
+--------------------------------------------------------------------------
 
-The `hello1` application is a web module that uses JavaServer Faces
+The `hello1` application is a web module that uses Jakarta Server Faces
 technology to display a greeting and response. You can use a text editor
 to view the application files, or you can use NetBeans IDE.
 
@@ -191,7 +191,7 @@ when you use NetBeans IDE to create an application.
 +
 A context parameter provides configuration information needed by a web
 application. An application can define its own context parameters. In
-addition, JavaServer Faces technology and Java Servlet technology define
+addition, Jakarta Server Faces technology and Jakarta Servlet technology define
 context parameters that an application can use.
 * A `servlet` element and its `servlet-mapping` element specifying the
 `FacesServlet`. All files with the `.xhtml` suffix will be matched:
@@ -228,7 +228,7 @@ In the `Hello.java` class, the annotations `javax.inject.Named` and
 bean using request scope. Scope defines how application data persists
 and is shared.
 
-The most commonly used scopes in JavaServer Faces applications are the
+The most commonly used scopes in Jakarta Server Faces applications are the
 following:
 
 * Request (`@RequestScoped`): Request scope persists during a single
@@ -242,7 +242,7 @@ use session scope.
 * Application (`@ApplicationScoped`): Application scope persists across
 all users' interactions with a web application.
 
-For more information on scopes in JavaServer Faces technology, see
+For more information on scopes in Jakarta Server Faces technology, see
 link:jsf-configure002.html#GIRCR[Using Managed Bean Scopes].
 
 [[BNADZ]][[packaging-and-deploying-the-hello1-web-module]]

src/main/jbake/content/webapp004.adoc

@@ -1,18 +1,18 @@
 type=page
 status=published
-title=A Web Module That Uses Java Servlet Technology: The hello2 Example
+title=A Web Module That Uses Jakarta Servlet Technology: The hello2 Example
 next=webapp005.html
 prev=webapp003.html
 ~~~~~~
-A Web Module That Uses Java Servlet Technology: The hello2 Example
-==================================================================
+A Web Module That Uses Jakarta Servlet Technology: The hello2 Example
+=====================================================================
 
 [[BNAEO]][[a-web-module-that-uses-java-servlet-technology-the-hello2-example]]
 
-A Web Module That Uses Java Servlet Technology: The hello2 Example
-------------------------------------------------------------------
+A Web Module That Uses Jakarta Servlet Technology: The hello2 Example
+---------------------------------------------------------------------
 
-The `hello2` application is a web module that uses Java Servlet
+The `hello2` application is a web module that uses Jakarta Servlet
 technology to display a greeting and response. You can use a text editor
 to view the application files, or you can use NetBeans IDE.
 
@@ -71,8 +71,8 @@ Examining the hello2 Web Module
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 The `hello2` application behaves almost identically to the `hello1`
-application, but it is implemented using Java Servlet technology instead
-of JavaServer Faces technology. You can use a text editor to view the
+application, but it is implemented using Jakarta Servlet technology instead
+of Jakarta Server Faces technology. You can use a text editor to view the
 application files, or you can use NetBeans IDE.
 
 [[GJWWA]][[to-view-the-hello2-web-module-using-netbeans-ide]]

src/main/jbake/content/webapp005.adoc

@@ -190,7 +190,7 @@ This section explains how to use a couple of the annotations supported
 by a web container to inject resources.
 link:persistence-basicexamples.html#GIJST[Chapter 41, "Running the
 Persistence Examples"], explains how web applications use annotations
-supported by the Java Persistence API.
+supported by Jakarta Persistence.
 link:security-webtier.html#BNCAS[Chapter 51, "Getting Started Securing
 Web Applications"], explains how to use annotations to specify
 information about securing web applications. See
@@ -270,16 +270,16 @@ as shown by the following example:
 })
 ----
 
-The web application examples in this tutorial use the Java Persistence
-API to access relational databases. This API does not require you to
+The web application examples in this tutorial use Jakarta Persistence
+to access relational databases. This API does not require you to
 explicitly create a connection to a data source. Therefore, the examples
 do not use the `@Resource` annotation to inject a data source. However,
 this API supports the `@PersistenceUnit` and `@PersistenceContext`
 annotations for injecting `EntityManagerFactory` and `EntityManager`
 instances, respectively.
 link:persistence-basicexamples.html#GIJST[Chapter 41, "Running the
 Persistence Examples"] describes these annotations and the use of the
-Java Persistence API in web applications.
+Jakarta Persistence in web applications.
 
 [[BNAEX]][[declaring-a-reference-to-a-web-service]]
 

src/main/jbake/content/webapp006.adoc

@@ -14,9 +14,9 @@ Further Information about Web Applications
 
 For more information on web applications, see
 
-* JavaServer Faces 2.3 specification:
+* Jakarta Server Faces 2.3 specification:
 +
-`https://jcp.org/en/jsr/detail?id=372`
-* Java Servlet 4.0 specification:
+`https://jakarta.ee/specifications/faces/2.3/`
+* Jakarta Servlet 4.0 specification:
 +
-`https://jcp.org/en/jsr/detail?id=369`
+`https://jakarta.ee/specifications/servlet/4.0/`