Home > Articles > Web Services > XML

Sams Teach Yourself XML in 21 Days

Sep 16, 2005

📄 Contents

␡

⎙ Print

< Back Page 229 of 288 Next >

Recommended Book 

Sams Teach Yourself XML in 21 Days, 3rd Edition

Learn More Buy

A SOAP Example in Java

You can use SOAP with Java by using Web services, but doing so is more advanced than the Java work you've already seen in this book. In this example, you're going to use Java servlets on a Web server. For this example you'll use two servlets—one that sends the SOAP message and one that receives that message. The receiving servlet will decode the data in the SOAP message and return a new SOAP message indicating that it has understood.

You need a Web server that can run Java servlets for this example. The Tomcat server is the premier Web server for JavaServer Pages and servlets; you can download it from http://jakarta.apache.org/tomcat/. Downloading and installing Tomcat is not difficult; just use the installation directions that come with Tomcat. After you have Tomcat installed and running, navigate to http://localhost:8080/index.html, and you should see Tomcat running, as in Figure 18.1.

Figure 18.1 Getting the Tomcat server running.

To support Web services, you also need some additional Java packages. There are two options when you're using SOAP with Java—you can download the Java XML pack, which is at (as of this writing) http://java.sun.com/xml/downloads/javaxmlpack.html, or you can download the Java Web Services Developer's Pack, which is at (as of this writing) http://java.sun.com/webservices/webservicespack.html. It's easiest to download the Java XML pack, which is a simple zipped file that holds the JAR files you'll need: jaxm-api.jar, saaj-api.jar, andactivation.jar. You also need servlet.jar to create servlets, and this file comes with Tomcat, in the lib directory.

There's another step you need to take at this point: You need to set up Tomcat to work with Java XML Messaging (JAXM). You should stop Tomcat if it's running and copy jaxm-docs.war, which comes with the Java XML Pack or the Java Web Services Developer's Pack, to the Tomcat webapps directory, and then you can restart Tomcat and navigate to http://localhost:8080/jaxm-docs/tomcat.html for directions. Setting up Tomcat for JAXM simply involves copying some JAR (Java archive) and WAR (Web archive) files.

With Tomcat set up, you're ready to write the two SOAP servlets you're going to use today: the server, ch18_04, and the client, ch18_05. For this example, you'll start by opening a new Web page, ch18_06.html, that has a link in it to the server servlet, ch18_04. When that link is clicked, the server will send a SOAP message to the client servlet, indicating how many laptops you have in stock, and the client servlet will then send back an acknowledging SOAP message. The actual SOAP messages will also be written to file so you can see what the two servlets sent each other. You'll start by creating the server servlet, ch18_04.

Creating the Server

The first servlet will create and send a SOAP message indicating that you have 216 laptops available. You start by creating a SOAP connection object named connection:

package soapExample;

import java.io.*;
import java.net.*;
import javax.servlet.*;
import javax.xml.soap.*;
import javax.activation.*;
import javax.servlet.http.*;

public class ch18_04 extends HttpServlet
{
    private SOAPConnection connection;

    public void init(ServletConfig servletConfig) throws ServletException
    {
        super.init(servletConfig);

        try {

           SOAPConnectionFactory connectionFactory =

                       SOAPConnectionFactory.newInstance();

               connection = connectionFactory.createConnection();

           } catch(Exception e) {}
    }

When the servlet is called, its doGet method will be executed, and that's the method where most of your code will go. Here, you create a MessageFactory object and a SOAP message:

public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException
{
    String outString ="<HTML><H1>Sending and reading the SOAP Message</H1><P>";

    try {

           MessageFactory messageFactory = MessageFactory.newInstance();

           SOAPMessage outgoingMessage = messageFactory.createMessage();
        .
        .
        .

Create the parts of the message, including the envelope, header, and body, like this:

public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException
{
    String outString ="<HTML><H1>Sending and reading the SOAP Message</H1><P>";

    try {
        MessageFactory messageFactory = MessageFactory.newInstance();
        SOAPMessage outgoingMessage = messageFactory.createMessage();

        SOAPPart soappart = outgoingMessage.getSOAPPart();

           SOAPEnvelope envelope = soappart.getEnvelope();

           SOAPHeader header = envelope.getHeader();

           SOAPBody body = envelope.getBody();
    .
    .
    .

Now you add an element named <laptops:numberAvailable> to the SOAP message's body and indicate that there are 216 laptops available, like this:

body.addBodyElement(envelope.createName("numberAvailable", "laptops",
"http://www.XMLPowerCorp.com")).addTextNode("216");

You can also add attachments to SOAP messages, which you'll do next. In this case, you'll send a text attachment. A handy text file is the ch18_06.html document that you browse to in order to run this example, and here's how to attach it to the SOAP message:

StringBuffer serverUrl = new StringBuffer();
serverUrl.append(request.getScheme()).append("://")
    .append(request.getServerName());
serverUrl.append(":").append(request.getServerPort())
    .append(request.getContextPath());
String baseUrl = serverUrl.toString();
URL url = new URL(baseUrl + "/ch18_06.html");

AttachmentPart attachmentpart =
    outgoingMessage.createAttachmentPart(new DataHandler(url)) ;
attachmentpart.setContentType("text/html");
outgoingMessage.addAttachmentPart(attachmentpart) ;

Now you will write our SOAP message to a file, out.msg, so you can look at it later and send that message to the client:

URL client = new URL(baseUrl + "/ch18_05");

FileOutputStream outgoingFile = new FileOutputStream("out.msg");
outgoingMessage.writeTo(outgoingFile);
outgoingFile.close();

outString += "SOAP outgoingMessage sent (see out.msg). <BR>";

SOAPMessage incomingMessage = connection.call(outgoingMessage, client);

The SOAP message you get back from the client, which should acknowledge that there are 216 laptops available, is in the incomingMessage object, which you write to the file in.msg so you can take a look at it later:

if (incomingMessage != null) {
    FileOutputStream incomingFile = new FileOutputStream("in.msg");
    incomingMessage.writeTo(incomingFile);
    incomingFile.close();
    outString += "SOAP outgoingMessage received (see in.msg).</HTML>";
}
    .
    .
    .

That completes the server, which is your ch18_04 servlet. The server's code, ch18_04.java, is shown in Listing 18.4.

Example 18.4. SOAP Server (`ch18_04.java`)

package soapExample;

import java.io.*;
import java.net.*;
import javax.servlet.*;
import javax.xml.soap.*;
import javax.activation.*;
import javax.servlet.http.*;

public class ch18_04 extends HttpServlet
{
    private SOAPConnection connection;

    public void init(ServletConfig servletConfig) throws ServletException
    {
        super.init(servletConfig);

        try {
        SOAPConnectionFactory connectionFactory =
                    SOAPConnectionFactory.newInstance();
            connection = connectionFactory.createConnection();
        } catch(Exception e) {}
    }

    public void doGet(HttpServletRequest request, HttpServletResponse response)
    throws ServletException
    {
        String outString =
            "<HTML><H1>Sending and reading the SOAP Message</H1><P>";

        try {
            MessageFactory messageFactory = MessageFactory.newInstance();
            SOAPMessage outgoingMessage = messageFactory.createMessage();

            SOAPPart soappart = outgoingMessage.getSOAPPart();
            SOAPEnvelope envelope = soappart.getEnvelope();
            SOAPHeader header = envelope.getHeader();
            SOAPBody body = envelope.getBody();

            body.addBodyElement(envelope.createName("numberAvailable",
            "laptops",
            "http://www.XMLPowerCorp.com")).addTextNode("216");

            StringBuffer serverUrl = new StringBuffer();
            serverUrl.append(request.getScheme()).append("://").
                append(request.getServerName());
            serverUrl.append(":").append(request.getServerPort()).
                append(request.getContextPath());
            String baseUrl = serverUrl.toString();
            URL url = new URL(baseUrl + "/ch18_06.html");

            AttachmentPart attachmentpart = outgoingMessage.
                createAttachmentPart(new DataHandler(url));
            attachmentpart.setContentType("text/html");
            outgoingMessage.addAttachmentPart(attachmentpart);

            URL client = new URL(baseUrl + "/ch18_05");

            FileOutputStream outgoingFile = new FileOutputStream("out.msg");
            outgoingMessage.writeTo(outgoingFile);
            outgoingFile.close();

            outString += "SOAP outgoingMessage sent (see out.msg). <BR>";

            SOAPMessage incomingMessage = connection.
                call(outgoingMessage, client);

            if (incomingMessage != null) {
                FileOutputStream incomingFile = new FileOutputStream("in.msg");
                incomingMessage.writeTo(incomingFile);
                incomingFile.close();
                outString +=
                    "SOAP outgoingMessage received (see in.msg).</HTML>";
            }

        } catch(Throwable e) {}

        try {
            OutputStream outputStream = response.getOutputStream();
            outputStream.write(outString.getBytes());
            outputStream.flush();
            outputStream.close();
        } catch (IOException e) {}
    }
}

Creating the Client

The next step is to create the client, the ch18_05 servlet, which gets the server's SOAP message, interprets it, and sends a message back, indicating that it has understood the incoming message. Start by basing this servlet on the JAXMServlet class so that it can handle SOAP messages and creating a MessageFactory object so you can send SOAP messages:

package soapExample;

import java.util.*;
import javax.servlet.*;
import javax.xml.soap.*;
import javax.servlet.http.*;
import javax.xml.messaging.*;

public class ch18_05 extends JAXMServlet implements ReqRespListener
{
    static MessageFactory messageFactory = null;

    public void init(ServletConfig servletConfig) throws ServletException
    {
        super.init(servletConfig);

           try {

               messageFactory = MessageFactory.newInstance();

           } catch (Exception ex) {}
    }
        .
        .
        .

Now you can decipher the incoming SOAP message by getting the value of the <laptops:numberAvailable> element and storing it in a variable named element, like this:

public SOAPMessage onMessage(SOAPMessage msg)
{
    try {

           SOAPPart soappart = msg.getSOAPPart();

           SOAPEnvelope incomingEnvelope = soappart.getEnvelope();

           SOAPBody body = incomingEnvelope.getBody();


           Iterator iterator = body.getChildElements(

           incomingEnvelope.createName("numberAvailable", "laptops",

               "http://www.XMLPowerCorp.com"));


           SOAPElement element;

           element = (SOAPElement) iterator.next();
        .
        .
        .

The number of laptops left in stock can now be accessed with element.getValue(), and here's how to create a SOAP message to send back to the server, indicating that you've gotten that data:


               SOAPMessage message = messageFactory.createMessage();

               SOAPEnvelope envelope = message.getSOAPPart().getEnvelope();


               envelope.getBody().addChildElement(envelope.

                   createName("Response")).addTextNode(

                   "Got the SOAP message indicating there are " +

                   element.getValue() +

                   " laptops available."

               );
        .
        .
        .
}

Finally, send the new SOAP message that acknowledges the number of laptops back to the client by returning the new message, which automatically sends it back to the server servlet, ch18_04, as you can see in ch18_05.java, the SOAP client, in Listing 18.5.

Example 18.5. A SOAP Client (`ch18_05.java`)

package soapExample;

import java.util.*;
import javax.servlet.*;
import javax.xml.soap.*;
import javax.servlet.http.*;
import javax.xml.messaging.*;

public class ch18_05 extends JAXMServlet implements ReqRespListener
{
    static MessageFactory messageFactory = null;

    public void init(ServletConfig servletConfig) throws ServletException
    {
        super.init(servletConfig);
        try {
            messageFactory = MessageFactory.newInstance();
        } catch (Exception ex) {}
    }

    public SOAPMessage onMessage(SOAPMessage msg)
    {
        try {
            SOAPPart soappart = msg.getSOAPPart();
            SOAPEnvelope incomingEnvelope = soappart.getEnvelope();
            SOAPBody body = incomingEnvelope.getBody();

            Iterator iterator = body.getChildElements(
            incomingEnvelope.createName("numberAvailable", "laptops",
                "http://www.XMLPowerCorp.com"));

            SOAPElement element;
            element = (SOAPElement) iterator.next();

            SOAPMessage message = messageFactory.createMessage();
            SOAPEnvelope envelope = message.getSOAPPart().getEnvelope();

            envelope.getBody().addChildElement(envelope
                .createName("Response")).addTextNode(
                "Got the SOAP message indicating there are " +
                    element.getValue() +
                " laptops available."
            );

            return message;
        } catch(Exception e) {return null;}
    }
}

To compile these new servlets, ch18_04.java and ch18_05.java, you need to have servlet.jar, jaxm-api.jar, saaj-api.jar, and activation.jar in the Java classpath environment variable. For example, if those JAR files are in the same directory as ch18_04.java and ch18_05.java, here's what this looks like:

%set classpath=servlet.jar;jaxm-api.jar;saaj-api.jar;activation.jar
%javac ch18_04.java
%javac ch18_05.java

If the JAR files are in the same directory as ch18_04.java and ch18_05.java, you need to make sure to preface every JAR file filename with its correct path.

This gives you the compiled files you need, ch18_04.class and ch18_05.class. How can you run the server, ch18_04.class? Here, you'll use an HTML document, ch18_06.html, to call the ch18_04.class servlet by using a hyperlink. Listing 18.6 shows how this HTML document works. When the user clicks the hyperlink, the server servlet is called, the server servlet sends a SOAP message to the client servlet, and the client servlet returns a SOAP message to the server.

Example 18.6. The SOAP Example Introduction Page (`ch18_06.html`)

<HTML>
    <HEAD>
        <TITLE>SOAP and Java</TITLE>
    </HEAD>

    <BODY>
        <H1>SOAP and Java</H1>

           Click <A HREF="ch18_04">here</a> to send the SOAP message.
    </BODY>
</HTML>

Now you need to install all that you've done in the Tomcat server. To do that, begin by creating a file named web.xml that will tell Tomcat about the ch18_04.class and ch18_05.class files so that you can use those files with Tomcat. Here's what web.xml looks like:

<?xml version="1.0" encoding="ISO-8859-1"?>

<!DOCTYPE web-app
    PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.2//EN"
    "http://java.sun.com/j2ee/dtds/web-app_2_2.dtd">

<web-app>
    <servlet>
        <servlet-name>
            ch18_04
        </servlet-name>
        <servlet-class>
            soapExample.ch18_04
        </servlet-class>
    </servlet>

    <servlet>
        <servlet-name>
            ch18_05
        </servlet-name>
        <servlet-class>
            soapExample.ch18_05
        </servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>
            ch18_04
        </servlet-name>
        <url-pattern>
            /ch18_04
        </url-pattern>
    </servlet-mapping>

    <servlet-mapping>
        <servlet-name>
            ch18_05
        </servlet-name>
        <url-pattern>
            /ch18_05
        </url-pattern>
    </servlet-mapping>
</web-app>

Now that you have all the files you'll need, you can install them in the Tomcat webapps directory in order to make them available through the Tomcat server. You'll install these files in a directory named JavaSoap and place your actual servlet code in a directory named soapExample (which is the Java package for those servlets). Here's what the completed directory structure looks like:

webapps [This is a directory]
|____JavaSoap [This is a directory]
     |____ch18_06.html [Our starting Web page]
     |____WEB-INF [This is a directory]
          |____web.xml [Configures Tomcat]
          |____classes [This is a directory]
               |____soapExample [This is a directory]
                    |____ch18_04.class [The server servlet]
                    |____ch18_05.class [The client servlet]

After you copy these files as shown here, start Tomcat (or if it was already started, stop it and start it again). Now all you need to do is navigate a browser to http://localhost:8080/soap/ch18_06.html, as shown in Figure 18.2.

Figure 18.2 The Java SOAP example's opening page.

Now click the hyperlink shown in Figure 18.2 in order to call the server servlet, which sends the first SOAP message, stating the number of laptops available in stock, to the client servlet, which sends back an acknowledgement. Figure 18.3 shows the results of calling the server servlet.

Figure 18.3 The results of the Java SOAP example.

What does the SOAP message sent from the server to the client look like? You can see it in the file out.msg, which is written to the Tomcat bin directory. Note that out.msg contains not only your SOAP message, but also the attached text, ch18_06.html:

------=_Part_4_6912871.1056396066449
Content-Type: text/xml

<?xml version="1.0" encoding="UTF-8"?>
<soap-env:Envelope xmlns:soap-env="http://schemas.xmlsoap.org/soap/envelope/">
    <soap-env:Header/>
    <soap-env:Body>
        <laptops:numberAvailable
            xmlns:laptops="http://www.XMLPowerCorp.com">
            216
        </laptops:numberAvailable>
    </soap-env:Body>
</soap-env:Envelope>
------=_Part_4_6912871.1056396066449
Content-Type: text/html

<HTML>
    <HEAD>
        <TITLE>SOAP and Java</TITLE>
    </HEAD>

    <BODY>
        <H1>SOAP and Java</H1>
        Click <A HREF="ch18_04">here</a> to send the SOAP message.
    </BODY>
</html>

------=_Part_4_6912871.1056396066449--

Here's what the SOAP message the client sent back to the server, as the code stored in in.msg, looks like (note that the client is acknowledging the data the server sent):

<?xml version="1.0" encoding="UTF-8"?>
<soap-env:Envelope
    xmlns:soap-env="http://schemas.xmlsoap.org/soap/envelope/">
    <soap-env:Header/>
    <soap-env:Body>
        <Response>
            Got the SOAP message indicating there are 216 laptops available.
        </Response>
    </soap-env:Body>
</soap-env:Envelope>

In this example you've been able to send, interpret, and reply to a SOAP message in Java. You've taken a look at programming examples in both .NET and Java now, and as you can see, both packages give SOAP support. You've just scratched the surface so far—covering the uses of SOAP can take whole books—but you have an idea what SOAP is good for from what you've seen. We'll turn now to RDF.

< Back Page 229 of 288 Next >

🔖 Save To Your Account

InformIT Promotional Mailings & Special Offers

I would like to receive exclusive offers and hear about products from InformIT and its family of brands. I can unsubscribe at any time.

Privacy Notice

Overview

Pearson Education, Inc., 221 River Street, Hoboken, New Jersey 07030, (Pearson) presents this site to provide information about products and services that can be purchased through this site.

This privacy notice provides an overview of our commitment to privacy and describes how we collect, protect, use and share personal information collected through this site. Please note that other Pearson websites and online products and services have their own separate privacy policies.

Collection and Use of Information

To conduct business and deliver products and services, Pearson collects and uses personal information in several ways in connection with this site, including:

Questions and Inquiries

For inquiries and questions, we collect the inquiry or question, together with name, contact details (email address, phone number and mailing address) and any other additional information voluntarily submitted to us through a Contact Us form or an email. We use this information to address the inquiry and respond to the question.

Online Store

For orders and purchases placed through our online store on this site, we collect order details, name, institution name and address (if applicable), email address, phone number, shipping and billing addresses, credit/debit card information, shipping options and any instructions. We use this information to complete transactions, fulfill orders, communicate with individuals placing orders or visiting the online store, and for related purposes.

Surveys

Pearson may offer opportunities to provide feedback or participate in surveys, including surveys evaluating Pearson products, services or sites. Participation is voluntary. Pearson collects information requested in the survey questions and uses the information to evaluate, support, maintain and improve products, services or sites, develop new products and services, conduct educational research and for other purposes specified in the survey.

Contests and Drawings

Occasionally, we may sponsor a contest or drawing. Participation is optional. Pearson collects name, contact information and other information specified on the entry form for the contest or drawing to conduct the contest or drawing. Pearson may collect additional personal information from the winners of a contest or drawing in order to award the prize and for tax reporting purposes, as required by law.

Newsletters

If you have elected to receive email newsletters or promotional mailings and special offers but want to unsubscribe, simply email information@informit.com.

Service Announcements

On rare occasions it is necessary to send out a strictly service related announcement. For instance, if our service is temporarily suspended for maintenance we might send users an email. Generally, users may not opt-out of these communications, though they can deactivate their account information. However, these communications are not promotional in nature.

Customer Service

We communicate with users on a regular basis to provide requested services and in regard to issues relating to their account we reply via email or phone in accordance with the users' wishes when a user submits their information through our Contact Us form.

Other Collection and Use of Information

Application and System Logs

Pearson automatically collects log data to help ensure the delivery, availability and security of this site. Log data may include technical information about how a user or visitor connected to this site, such as browser type, type of computer/device, operating system, internet service provider and IP address. We use this information for support purposes and to monitor the health of the site, identify problems, improve service, detect unauthorized access and fraudulent activity, prevent and respond to security incidents and appropriately scale computing resources.

Web Analytics

Pearson may use third party web trend analytical services, including Google Analytics, to collect visitor information, such as IP addresses, browser types, referring pages, pages visited and time spent on a particular site. While these analytical services collect and report information on an anonymous basis, they may use cookies to gather web trend information. The information gathered may enable Pearson (but not the third party web trend services) to link information with application and system log data. Pearson uses this information for system administration and to identify problems, improve service, detect unauthorized access and fraudulent activity, prevent and respond to security incidents, appropriately scale computing resources and otherwise support and deliver this site and its services.

Cookies and Related Technologies

This site uses cookies and similar technologies to personalize content, measure traffic patterns, control security, track use and access of information on this site, and provide interest-based messages and advertising. Users can manage and block the use of cookies through their browser. Disabling or blocking certain cookies may limit the functionality of this site.

Do Not Track

This site currently does not respond to Do Not Track signals.

Security

Pearson uses appropriate physical, administrative and technical security measures to protect personal information from unauthorized access, use and disclosure.

Children

This site is not directed to children under the age of 13.

Marketing

Pearson may send or direct marketing communications to users, provided that

Pearson will not use personal information collected or processed as a K-12 school service provider for the purpose of directed or targeted advertising.
Such marketing is consistent with applicable law and Pearson's legal obligations.
Pearson will not knowingly direct or send marketing communications to an individual who has expressed a preference not to receive marketing.
Where required by applicable law, express or implied consent to marketing exists and has not been withdrawn.

Pearson may provide personal information to a third party service provider on a restricted basis to provide marketing solely on behalf of Pearson or an affiliate or customer for whom Pearson is a service provider. Marketing preferences may be changed at any time.

Correcting/Updating Personal Information

If a user's personally identifiable information changes (such as your postal address or email address), we provide a way to correct or update that user's personal data provided to us. This can be done on the Account page. If a user no longer desires our service and desires to delete his or her account, please contact us at customer-service@informit.com and we will process the deletion of a user's account.

Choice/Opt-out

Users can always make an informed choice as to whether they should proceed with certain services offered by InformIT. If you choose to remove yourself from our mailing list(s) simply visit the following page and uncheck any communication you no longer want to receive: www.informit.com/u.aspx.

Sale of Personal Information

Pearson does not rent or sell personal information in exchange for any payment of money.

While Pearson does not sell personal information, as defined in Nevada law, Nevada residents may email a request for no sale of their personal information to NevadaDesignatedRequest@pearson.com.

Supplemental Privacy Statement for California Residents

California residents should read our Supplemental privacy statement for California residents in conjunction with this Privacy Notice. The Supplemental privacy statement for California residents explains Pearson's commitment to comply with California law and applies to personal information of California residents collected in connection with this site and the Services.

Sharing and Disclosure

Pearson may disclose personal information, as follows:

As required by law.
With the consent of the individual (or their parent, if the individual is a minor)
In response to a subpoena, court order or legal process, to the extent permitted or required by law
To protect the security and safety of individuals, data, assets and systems, consistent with applicable law
In connection the sale, joint venture or other transfer of some or all of its company or assets, subject to the provisions of this Privacy Notice
To investigate or address actual or suspected fraud or other illegal activities
To exercise its legal rights, including enforcement of the Terms of Use for this site or another contract
To affiliated Pearson companies and other companies and organizations who perform work for Pearson and are obligated to protect the privacy of personal information consistent with this Privacy Notice
To a school, organization, company or government agency, where Pearson collects or processes the personal information in a school setting or on behalf of such organization, company or government agency.

Links

This web site contains links to other sites. Please be aware that we are not responsible for the privacy practices of such other sites. We encourage our users to be aware when they leave our site and to read the privacy statements of each and every web site that collects Personal Information. This privacy statement applies solely to information collected by this web site.

Requests and Contact

Please contact us about this Privacy Notice or if you have any requests or questions relating to the privacy of your personal information.

Changes to this Privacy Notice

We may revise this Privacy Notice through an updated posting. We will identify the effective date of the revision in the posting. Often, updates are made to provide greater clarity or to comply with changes in regulatory requirements. If the updates involve material changes to the collection, protection, use or disclosure of Personal Information, Pearson will provide notice of the change through a conspicuous notice on this site or other appropriate way. Continued use of the site after the effective date of a posted revision evidences acceptance. Please contact us if you have questions or concerns about the Privacy Notice or any objection to any revisions.

Last Update: November 17, 2020

Email Address