<?xml version="1.0"?>
<!--

    DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

    Copyright (c) 2010-2014 Oracle and/or its affiliates. All rights reserved.

    The contents of this file are subject to the terms of either the GNU
    General Public License Version 2 only ("GPL") or the Common Development
    and Distribution License("CDDL") (collectively, the "License").  You
    may not use this file except in compliance with the License.  You can
    obtain a copy of the License at
    http://glassfish.java.net/public/CDDL+GPL_1_1.html
    or packager/legal/LICENSE.txt.  See the License for the specific
    language governing permissions and limitations under the License.

    When distributing the software, include this License Header Notice in each
    file and include the License file at packager/legal/LICENSE.txt.

    GPL Classpath Exception:
    Oracle designates this particular file as subject to the "Classpath"
    exception as provided by Oracle in the GPL Version 2 section of the License
    file that accompanied this code.

    Modifications:
    If applicable, add the following below the License Header, with the fields
    enclosed by brackets [] replaced by your own identifying information:
    "Portions Copyright [year] [name of copyright owner]"

    Contributor(s):
    If you wish your version of this file to be governed by only the CDDL or
    only the GPL Version 2, indicate your decision by adding "[Contributor]
    elects to include this software in this distribution under the [CDDL or GPL
    Version 2] license."  If you don't indicate a single choice of license, a
    recipient has the option to distribute your version of this file under
    either the CDDL, the GPL Version 2 or to extend the choice of license to
    its licensees as provided above.  However, if you add GPL Version 2 code
    and therefore, elected the GPL Version 2 license, then the option applies
    only if the new code is made subject to such option by the copyright
    holder.

-->
<!DOCTYPE chapter [<!ENTITY % ents SYSTEM "jersey.ent" > %ents; ]>
<chapter xmlns="http://docbook.org/ns/docbook"
         version="5.0"
         xml:lang="en"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns:xi="http://www.w3.org/2001/XInclude"
         xmlns:xlink="http://www.w3.org/1999/xlink"
         xsi:schemaLocation="http://docbook.org/ns/docbook http://docbook.org/xml/5.0/xsd/docbook.xsd
                             http://www.w3.org/1999/xlink http://www.w3.org/1999/xlink.xsd"
         xml:id="getting-started">
    <title>Getting Started</title>

    <para>
        This chapter provides a quick introduction on how to get started building RESTful services using Jersey.
        The example described here uses the lightweight Grizzly HTTP server. At the end of this chapter you will
        see how to implement equivalent functionality as a JavaEE web application you can deploy on any servlet
        container supporting Servlet 2.5 and higher.
    </para>

    <section xml:id="new-from-archetype">
        <title>Creating a New Project from Maven Archetype</title>

        <para>
            Jersey project is built using &maven.link; software project build and management tool. All modules produced as
            part of Jersey project build are pushed to the &maven.central.repo.link;. Therefore it is very convenient to work
            with Jersey for any Maven-based project as all the released (non-SNAPSHOT) Jersey dependencies are readily
            available without a need to configure a special maven repository to consume the Jersey modules.

            <note>
                <para>
                    In case you want to depend on the latest SNAPSHOT versions of Jersey modules, the following repository
                    configuration needs to be added to your Maven project pom:

                    <programlisting language="xml" linenumbering="unnumbered">&lt;repository&gt;
    &lt;id&gt;snapshot-repository.java.net&lt;/id&gt;
    &lt;name&gt;Java.net Snapshot Repository for Maven&lt;/name&gt;
    &lt;url&gt;https://maven.java.net/content/repositories/snapshots/&lt;/url&gt;
    &lt;layout&gt;default&lt;/layout&gt;
&lt;/repository&gt;</programlisting>
                </para>
            </note>
        </para>
        <para>
            Since starting from a Maven project is the most convenient way for working with Jersey, let's now have a look
            at this approach. We will now create a new Jersey project that runs on top of a &grizzly.link; container. We will
            use a Jersey-provided maven archetype. To create the project, execute the following Maven command in the directory
            where the new project should reside:

            <programlisting language="bash" linenumbering="unnumbered">mvn archetype:generate -DarchetypeArtifactId=jersey-quickstart-grizzly2 \
-DarchetypeGroupId=org.glassfish.jersey.archetypes -DinteractiveMode=false \
-DgroupId=com.example -DartifactId=simple-service -Dpackage=com.example \
-DarchetypeVersion=&version;</programlisting>

            Feel free to adjust the <literal>groupId</literal>, <literal>package</literal> and/or <literal>artifactId</literal>
            of your new project. Alternatively, you can change it by updating the new project pom.xml once it gets generated.
        </para>
    </section>
    <section xml:id="new-project-structure">
        <title>Exploring the Newly Created Project</title>

        <para>
            Once the project generation from a Jersey maven archetype is successfully finished, you should see the new
            <literal>simple-service</literal> project directory created in your current location. The directory contains
            a standard Maven project structure:

            <simplelist>
                <member>
                    Project build and management configuration is described in the <literal>pom.xml</literal> located
                    in the project root directory.
                </member>
                <member>Project sources are located under <literal>src/main/java</literal>.</member>
                <member>Project test sources are located under <literal>src/test/java</literal>.</member>
            </simplelist>

            There are 2 classes in the project source directory in the <literal>com.example</literal> package.
            The <literal>Main</literal> class is responsible for bootstrapping the Grizzly container as well as configuring
            and deploying the project's JAX-RS application to the container. Another class in the same package
            is <literal>MyResource</literal> class, that contains implementation of a simple JAX-RS resource.
            It looks like this:

            <programlisting language="java" linenumbering="numbered">package com.example;

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

/**
 * Root resource (exposed at "myresource" path)
 */
@Path("myresource")
public class MyResource {

    /**
     * Method handling HTTP GET requests. The returned object will be sent
     * to the client as "text/plain" media type.
     *
     * @return String that will be returned as a text/plain response.
     */
    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String getIt() {
        return "Got it!";
    }
}</programlisting>

            A JAX-RS resource is an annotated POJO that provides so-called <emphasis>resource methods</emphasis> that
            are able to handle HTTP requests for URI paths that the resource is bound to. See
            <xref linkend="jaxrs-resources" /> for a complete guide to JAX-RS resources. In our case, the resource
            exposes a single resource method that is able to handle HTTP &lit.http.GET; requests, is bound to
            <literal>/myresource</literal> URI path and can produce responses with response message content represented
            in <literal>"text/plain"</literal> media type. In this version, the resource returns the same
            <literal>"Got it!"</literal> response to all client requests.
        </para>
        <para>
            The last piece of code that has been generated in this skeleton project is a <literal>MyResourceTest</literal>
            unit test class that is located in the same <literal>com.example</literal> package as the
            <literal>MyResource</literal> class, however, this unit test class is placed into the maven project test source
            directory <literal>src/test/java</literal> (certain code comments and JUnit imports have been excluded for brevity):

            <programlisting language="java" linenumbering="numbered">package com.example;

import javax.ws.rs.client.Client;
import javax.ws.rs.client.ClientBuilder;
import javax.ws.rs.client.WebTarget;

import org.glassfish.grizzly.http.server.HttpServer;

...

public class MyResourceTest {

    private HttpServer server;
    private WebTarget target;

    @Before
    public void setUp() throws Exception {
        server = Main.startServer();

        Client c = ClientBuilder.newClient();
        target = c.target(Main.BASE_URI);
    }

    @After
    public void tearDown() throws Exception {
        server.stop();
    }

    /**
     * Test to see that the message "Got it!" is sent in the response.
     */
    @Test
    public void testGetIt() {
        String responseMsg = target.path("myresource").request().get(String.class);
        assertEquals("Got it!", responseMsg);
    }
}</programlisting>

            In this unit test, a Grizzly container is first started and server application is deployed in the
            test <literal>setUp()</literal> method by a static call to <literal>Main.startServer()</literal>.
            Next, a JAX-RS client components are created in the same test set-up method. First a new JAX-RS client
            instance <literal>c</literal> is built and then a JAX-RS web target component pointing to the context root of our
            application deployed at <literal>http://localhost:8080/myapp/</literal> (a value of
            <literal>Main.BASE_URI</literal> constant) is stored into a <literal>target</literal> field of the unit test class.
            This field is then used in the actual unit test method (<literal>testGetIt()</literal>).
        </para>
        <para>
            In the <literal>testGetIt()</literal> method a fluent JAX-RS Client API is used to connect to and send
            a HTTP &lit.http.GET; request to the <literal>MyResource</literal> JAX-RS resource class listening on
            <literal>/myresource</literal> URI. As part of the same fluent JAX-RS API method invocation chain, a response is
            read as a Java <literal>String</literal> type. On the second line in the test method, the response content string
            returned from the server is compared with the expected phrase in the test assertion. To learn more about using
            JAX-RS Client API, please see the <xref linkend="client" /> chapter.
        </para>
    </section>

    <section xml:id="running-project">
        <title>Running the Project</title>
        <para>
            Now that we have seen the content of the project, let's try to test-run it. To do this, we need to invoke following
            command on the command line:

            <programlisting language="bash" linenumbering="unnumbered">mvn clean test</programlisting>

            This will compile the project and run the project unit tests. We should see a similar output that informs about a
            successful build once the build is finished:

            <screen linenumbering="unnumbered">Results :

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 34.527s
[INFO] Finished at: Sun May 26 19:26:24 CEST 2013
[INFO] Final Memory: 17M/490M
[INFO] ------------------------------------------------------------------------</screen>

            Now that we have verified that the project compiles and that the unit test passes, we can execute the application
            in a standalone mode. To do this, run the following maven command:

            <programlisting language="bash" linenumbering="unnumbered">mvn exec:java</programlisting>

            The application starts and you should soon see the following notification in your console:

            <screen linenumbering="unnumbered">May 26, 2013 8:08:45 PM org.glassfish.grizzly.http.server.NetworkListener start
INFO: Started listener bound to [localhost:8080]
May 26, 2013 8:08:45 PM org.glassfish.grizzly.http.server.HttpServer start
INFO: [HttpServer] Started.
Jersey app started with WADL available at http://localhost:8080/myapp/application.wadl
Hit enter to stop it...</screen>

            This informs you that the application has been started and it's WADL descriptor is available at
            <literal>http://localhost:8080/myapp/application.wadl</literal> URL. You can retrieve the WADL content by
            executing a <literal>curl http://localhost:8080/myapp/application.wadl</literal> command in your console
            or by typing the WADL URL into your favorite browser. You should get back an XML document in describing
            your deployed RESTful application in a WADL format. To learn more about working with WADL, check the
            <xref linkend="wadl" /> chapter.
        </para>
        <para>
            The last thing we should try before concluding this section is to see if we can communicate with our
            resource deployed at <literal>/myresource</literal> path. We can again either type the resource URL
            in the browser or we can use <literal>curl</literal>:

            <screen language="bash" linenumbering="unnumbered">$ curl http://localhost:8080/myapp/myresource
Got it!</screen>

            As we can see, the <literal>curl</literal> command returned with the <literal>Got it!</literal> message that
            was sent by our resource. We can also ask <literal>curl</literal> to provide more information about the response,
            for example we can let it display all response headers by using the <literal>-i</literal> switch:

            <screen language="bash" linenumbering="unnumbered">curl -i http://localhost:8080/myapp/myresource
HTTP/1.1 200 OK
Content-Type: text/plain
Date: Sun, 26 May 2013 18:27:19 GMT
Content-Length: 7

Got it!</screen>

            Here we see the whole content of the response message that our Jersey/JAX-RS application returned, including all
            the HTTP headers. Notice the <literal>Content-Type: text/plain</literal> header that was derived from the
            value of &jaxrs.Produces; annotation attached to the <literal>MyResource</literal> class.
        </para>
        <para>
            In case you want to see even more details about the communication between our <literal>curl</literal> client
            and our resource running on Jersey in a Grizzly I/O container, feel free to try other various options and switches
            that <literal>curl</literal> provides. For example, this last command will make <literal>curl</literal> output
            a lot of additional information about the whole communication:

            <screen language="bash" linenumbering="unnumbered"><![CDATA[$ curl -v http://localhost:8080/myapp/myresource
* About to connect() to localhost port 8080 (#0)
*   Trying ::1...
* Connection refused
*   Trying 127.0.0.1...
* connected
* Connected to localhost (127.0.0.1) port 8080 (#0)
> GET /myapp/myresource HTTP/1.1
> User-Agent: curl/7.25.0 (x86_64-apple-darwin11.3.0) libcurl/7.25.0 OpenSSL/1.0.1e zlib/1.2.7 libidn/1.22
> Host: localhost:8080
> Accept: */*
>
< HTTP/1.1 200 OK
< Content-Type: text/plain
< Date: Sun, 26 May 2013 18:29:18 GMT
< Content-Length: 7
<
* Connection #0 to host localhost left intact
Got it!* Closing connection #0]]></screen>
        </para>
    </section>

    <section xml:id="new-webapp">
        <title>Creating a JavaEE Web Application</title>
        <para>
            To create a Web Application that can be packaged as WAR and deployed in a Servlet container follow a similar process
            to the one described in <xref linkend="new-from-archetype" />.
            In addition to the Grizzly-based archetype, Jersey provides also a Maven archetype for creating web application
            skeletons. To create the new web application skeleton project, execute the following Maven command in the directory
            where the new project should reside:

            <programlisting language="bash" linenumbering="unnumbered">mvn archetype:generate -DarchetypeArtifactId=jersey-quickstart-webapp \
                -DarchetypeGroupId=org.glassfish.jersey.archetypes -DinteractiveMode=false \
                -DgroupId=com.example -DartifactId=simple-service-webapp -Dpackage=com.example \
                -DarchetypeVersion=&version;</programlisting>

            As with the Grizzly based project, feel free to adjust the <literal>groupId</literal>, <literal>package</literal>
            and/or <literal>artifactId</literal> of your new web application project. Alternatively, you can change it by updating
            the new project &lit.pom.xml; once it gets generated.
        </para>
        <para>
            Once the project generation from a Jersey maven archetype is successfully finished, you should see the new
            <literal>simple-service-webapp</literal> project directory created in your current location. The directory contains
            a standard Maven project structure, similar to the <literal>simple-service</literal> project content we have seen
            earlier, except it is extended with an additional web application specific content:

            <simplelist>
                <member>
                    Project build and management configuration is described in the <literal>pom.xml</literal> located
                    in the project root directory.
                </member>
                <member>Project sources are located under <literal>src/main/java</literal>.</member>
                <member>Project resources are located under <literal>src/main/resources</literal>.</member>
                <member>Project web application files are located under <literal>src/main/webapp</literal>.</member>
            </simplelist>

            The project contains the same <literal>MyResouce</literal> JAX-RS resource class. It does not contain any unit tests
            as well as it does not contain a <literal>Main</literal> class that was used to setup Grizzly container in the
            previous project. Instead, it contains the standard Java EE web application <literal>web.xml</literal> deployment
            descriptor under <literal>src/main/webapp/WEB-INF</literal>.
            The last component in the project is an <literal>index.jsp</literal> page that serves as a client for the
            <literal>MyResource</literal> resource class that is packaged and deployed with the application.
        </para>
        <para>
            To compile and package the application into a WAR, invoke the following maven command in your console:

            <programlisting language="bash" linenumbering="unnumbered">mvn clean package</programlisting>

            A successful build output will produce an output similar to the one below:

            <screen linenumbering="unnumbered">Results :

Tests run: 0, Failures: 0, Errors: 0, Skipped: 0

[INFO]
[INFO] --- maven-war-plugin:2.1.1:war (default-war) @ simple-service-webapp ---
[INFO] Packaging webapp
[INFO] Assembling webapp [simple-service-webapp] in [.../simple-service-webapp/target/simple-service-webapp]
[INFO] Processing war project
[INFO] Copying webapp resources [.../simple-service-webapp/src/main/webapp]
[INFO] Webapp assembled in [75 msecs]
[INFO] Building war: .../simple-service-webapp/target/simple-service-webapp.war
[INFO] WEB-INF/web.xml already added, skipping
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 9.067s
[INFO] Finished at: Sun May 26 21:07:44 CEST 2013
[INFO] Final Memory: 17M/490M
[INFO] ------------------------------------------------------------------------</screen>

            Now you are ready to take the packaged WAR (located under <literal>./target/simple-service-webapp.war</literal>)
            and deploy it to a Servlet container of your choice.
            <important>
                <para>
                    To deploy a Jersey application, you will need a Servlet container that supports Servlet 2.5 or later.
                    For full set of advanced features (such as JAX-RS 2.0 Async Support) you will need a Servlet 3.0 or later
                    compliant container.
                </para>
            </important>
        </para>
    </section>

     <section xml:id="heroku-webapp">
        <title>Creating a Web Application that can be deployed on Heroku</title>
        <para>
            To create a Web Application that can be either packaged as WAR and deployed in a Servlet container or that can be
            pushed and deployed on &heroku.link; the process is very similar to the one described in <xref linkend="new-webapp" />.
            To create the new web application skeleton project, execute the following Maven command in the directory
            where the new project should reside:

            <programlisting language="bash" linenumbering="unnumbered">mvn archetype:generate -DarchetypeArtifactId=jersey-heroku-webapp \
                -DarchetypeGroupId=org.glassfish.jersey.archetypes -DinteractiveMode=false \
                -DgroupId=com.example -DartifactId=simple-heroku-webapp -Dpackage=com.example \
                -DarchetypeVersion=&version;</programlisting>

            Adjust the <literal>groupId</literal>, <literal>package</literal> and/or <literal>artifactId</literal> of your new web
            application project to your needs or, alternatively, you can change it by updating the new project &lit.pom.xml; once it
            gets generated.
        </para>
        <para>
            Once the project generation from a Jersey maven archetype is successfully finished, you should see the new
            <literal>simple-heroku-webapp</literal> project directory created in your current location. The directory contains
            a standard Maven project structure:

            <simplelist>
                <member>
                    Project build and management configuration is described in the &lit.pom.xml; located
                    in the project root directory.
                </member>
                <member>Project sources are located under <literal>src/main/java</literal>.</member>
                <member>Project resources are located under <literal>src/main/resources</literal>.</member>
                <member>Project web application files are located under <literal>src/main/webapp</literal>.</member>
                <member>Project test-sources (based on &jersey.test.JerseyTest;) are located under <literal>src/test/java</literal>.</member>
                <member>Heroku system properties (OpenJDK version) are defined in <literal>system.properties</literal>.</member>
                <member>Lists of the process types in an application for Heroku is in <literal>Procfile</literal>.</member>
            </simplelist>

            The project contains one JAX-RS resource class, <literal>MyResouce</literal>, and one resource method which returns
            simple text message. To make sure the resource is properly tested there is also a end-to-end test-case
            in <literal>MyResourceTest</literal> (the test is based on &jersey.test.JerseyTest; from our <xref linkend="test-framework" />).
            Similarly to <literal>simple-service-webapp</literal>, the project contains the standard Java EE web application
            <literal>web.xml</literal> deployment descriptor under <literal>src/main/webapp/WEB-INF</literal> since the goal is to
            deploy the application in a Servlet container (the application will run in Jetty on Heroku).
        </para>
        <para>
            To compile and package the application into a WAR, invoke the following maven command in your console:

            <programlisting language="bash" linenumbering="unnumbered">mvn clean package</programlisting>

            A successful build output will produce an output similar to the one below:

            <screen linenumbering="unnumbered">    Results :

    Tests run: 1, Failures: 0, Errors: 0, Skipped: 0

    [INFO]
    [INFO] --- maven-war-plugin:2.2:war (default-war) @ simple-heroku-webapp ---
    [INFO] Packaging webapp
    [INFO] Assembling webapp [simple-heroku-webapp] in [.../simple-heroku-webapp/target/simple-heroku-webapp]
    [INFO] Processing war project
    [INFO] Copying webapp resources [.../simple-heroku-webapp/src/main/webapp]
    [INFO] Webapp assembled in [57 msecs]
    [INFO] Building war: .../simple-heroku-webapp/target/simple-heroku-webapp.war
    [INFO] WEB-INF/web.xml already added, skipping
    [INFO]
    [INFO] --- maven-dependency-plugin:2.8:copy-dependencies (copy-dependencies) @ simple-heroku-webapp ---
    [INFO] Copying hk2-locator-2.2.0-b21.jar to .../simple-heroku-webapp/target/dependency/hk2-locator-2.2.0-b21.jar
    [INFO] Copying jetty-security-9.0.6.v20130930.jar to .../simple-heroku-webapp/target/dependency/jetty-security-9.0.6.v20130930.jar
    [INFO] Copying asm-all-repackaged-2.2.0-b21.jar to .../simple-heroku-webapp/target/dependency/asm-all-repackaged-2.2.0-b21.jar
    [INFO] Copying jersey-common-2.5.jar to .../simple-heroku-webapp/target/dependency/jersey-common-2.5.jar
    [INFO] Copying validation-api-1.1.0.Final.jar to .../simple-heroku-webapp/target/dependency/validation-api-1.1.0.Final.jar
    [INFO] Copying jetty-webapp-9.0.6.v20130930.jar to .../simple-heroku-webapp/target/dependency/jetty-webapp-9.0.6.v20130930.jar
    [INFO] Copying jersey-container-servlet-2.5.jar to .../simple-heroku-webapp/target/dependency/jersey-container-servlet-2.5.jar
    [INFO] Copying cglib-2.2.0-b21.jar to .../simple-heroku-webapp/target/dependency/cglib-2.2.0-b21.jar
    [INFO] Copying osgi-resource-locator-1.0.1.jar to .../simple-heroku-webapp/target/dependency/osgi-resource-locator-1.0.1.jar
    [INFO] Copying hk2-utils-2.2.0-b21.jar to .../simple-heroku-webapp/target/dependency/hk2-utils-2.2.0-b21.jar
    [INFO] Copying hk2-api-2.2.0-b21.jar to .../simple-heroku-webapp/target/dependency/hk2-api-2.2.0-b21.jar
    [INFO] Copying jetty-io-9.0.6.v20130930.jar to .../simple-heroku-webapp/target/dependency/jetty-io-9.0.6.v20130930.jar
    [INFO] Copying jetty-server-9.0.6.v20130930.jar to .../simple-heroku-webapp/target/dependency/jetty-server-9.0.6.v20130930.jar
    [INFO] Copying jetty-util-9.0.6.v20130930.jar to .../simple-heroku-webapp/target/dependency/jetty-util-9.0.6.v20130930.jar
    [INFO] Copying jersey-client-2.5.jar to .../simple-heroku-webapp/target/dependency/jersey-client-2.5.jar
    [INFO] Copying jetty-http-9.0.6.v20130930.jar to .../simple-heroku-webapp/target/dependency/jetty-http-9.0.6.v20130930.jar
    [INFO] Copying guava-14.0.1.jar to .../simple-heroku-webapp/target/dependency/guava-14.0.1.jar
    [INFO] Copying jetty-xml-9.0.6.v20130930.jar to .../simple-heroku-webapp/target/dependency/jetty-xml-9.0.6.v20130930.jar
    [INFO] Copying jersey-server-2.5.jar to .../simple-heroku-webapp/target/dependency/jersey-server-2.5.jar
    [INFO] Copying jersey-container-servlet-core-2.5.jar to .../simple-heroku-webapp/target/dependency/jersey-container-servlet-core-2.5.jar
    [INFO] Copying javax.ws.rs-api-2.0.jar to .../simple-heroku-webapp/target/dependency/javax.ws.rs-api-2.0.jar
    [INFO] Copying jetty-servlet-9.0.6.v20130930.jar to .../simple-heroku-webapp/target/dependency/jetty-servlet-9.0.6.v20130930.jar
    [INFO] Copying javax.inject-2.2.0-b21.jar to .../simple-heroku-webapp/target/dependency/javax.inject-2.2.0-b21.jar
    [INFO] Copying javax.servlet-3.0.0.v201112011016.jar to .../simple-heroku-webapp/target/dependency/javax.servlet-3.0.0.v201112011016.jar
    [INFO] Copying javax.annotation-api-1.2.jar to .../simple-heroku-webapp/target/dependency/javax.annotation-api-1.2.jar
    [INFO] ------------------------------------------------------------------------
    [INFO] BUILD SUCCESS
    [INFO] ------------------------------------------------------------------------
    [INFO] Total time: 4.401s
    [INFO] Finished at: Mon Dec 09 20:19:06 CET 2013
    [INFO] Final Memory: 20M/246M
    [INFO] ------------------------------------------------------------------------</screen>

            Now that you know everything went as expected you are ready to:

            <itemizedlist>
                <listitem><simpara>
                    make some changes in your project,
                </simpara></listitem>
                <listitem><simpara>
                    take the packaged WAR (located under <literal>./target/simple-service-webapp.war</literal>) and deploy it to a
                    Servlet container of your choice, or
                </simpara></listitem>
                <listitem><simpara>
                    <xref linkend="deploy-it-on-heroku" />
                </simpara></listitem>
            </itemizedlist>

            <tip>
                <para>
                    If you want to make some changes to your application you can run the application locally by simply running
                    <code>mvn clean package jetty:run</code> (which starts the embedded Jetty server) or by
                    <code>java -cp target/classes:target/dependency/* com.example.heroku.Main</code> (this is how Jetty is
                    started on Heroku).
                </para>
            </tip>
        </para>
        <section xml:id="deploy-it-on-heroku">
            <title>Deploy it on Heroku</title>
            <para>
                We won't go into details how to create an account on &heroku.link; and setup the <literal>Heroku</literal> tools
                on your machine. You can find a lot of information in this article: <link xlink:href='https://devcenter.heroku.com/articles/getting-started-with-java'>Getting Started with Java on Heroku</link>.
                Instead, we'll take a look at the steps needed after your environment is ready.
            </para>
            <para>
                The first step is to create a Git repository from your project:
                <screen linenumbering="unnumbered">    $ git init
    Initialized empty Git repository in /.../simple-heroku-webapp/.git/</screen>
            </para>
            <para>
                Then, create a &heroku.link; instance and add a remote reference to your Git repository:
                <screen linenumbering="unnumbered">    $ heroku create
    Creating simple-heroku-webapp... done, stack is cedar
    http://simple-heroku-webapp.herokuapp.com/ | git@heroku.com:simple-heroku-webapp.git
    Git remote heroku added</screen>

                <note>
                    <para>
                        The name of the instance is changed in the output to <literal>simple-heroku-webapp</literal>. Your will be
                        named more like <literal>tranquil-basin-4744</literal>.
                    </para>
                </note>
            </para>
            <para>
                Add and commit files to your Git repository:
                <screen linenumbering="unnumbered">    $ git add src/ pom.xml Procfile system.properties</screen>
                <screen linenumbering="unnumbered">    $ git commit -a -m "initial commit"
    [master (root-commit) e2b58e3] initial commit
     7 files changed, 221 insertions(+)
     create mode 100644 Procfile
     create mode 100644 pom.xml
     create mode 100644 src/main/java/com/example/MyResource.java
     create mode 100644 src/main/java/com/example/heroku/Main.java
     create mode 100644 src/main/webapp/WEB-INF/web.xml
     create mode 100644 src/test/java/com/example/MyResourceTest.java
     create mode 100644 system.properties</screen>
            </para>
            <para>
                Push changes to Heroku:
                <screen linenumbering="unnumbered">    $ git push heroku master
    Counting objects: 21, done.
    Delta compression using up to 8 threads.
    Compressing objects: 100% (11/11), done.
    Writing objects: 100% (21/21), 3.73 KiB | 0 bytes/s, done.
    Total 21 (delta 0), reused 0 (delta 0)

    -----> Java app detected
    -----> Installing OpenJDK 1.7... done
    -----> Installing Maven 3.0.3... done
    -----> Installing settings.xml... done
    -----> executing /app/tmp/cache/.maven/bin/mvn -B -Duser.home=/tmp/build_992cc747-26d6-4800-bdb1-add47b9583cd -Dmaven.repo.local=/app/tmp/cache/.m2/repository -s /app/tmp/cache/.m2/settings.xml -DskipTests=true clean install
           [INFO] Scanning for projects...
           [INFO]
           [INFO] ------------------------------------------------------------------------
           [INFO] Building simple-heroku-webapp 1.0-SNAPSHOT
           [INFO] ------------------------------------------------------------------------
           [INFO]
           [INFO] --- maven-clean-plugin:2.4.1:clean (default-clean) @ simple-heroku-webapp ---
           [INFO]
           [INFO] --- maven-resources-plugin:2.4.3:resources (default-resources) @ simple-heroku-webapp ---
           [INFO] Using 'UTF-8' encoding to copy filtered resources.
           [INFO] skip non existing resourceDirectory /tmp/build_992cc747-26d6-4800-bdb1-add47b9583cd/src/main/resources
           [INFO]
           [INFO] --- maven-compiler-plugin:2.5.1:compile (default-compile) @ simple-heroku-webapp ---
           [INFO] Compiling 2 source files to /tmp/build_992cc747-26d6-4800-bdb1-add47b9583cd/target/classes
           [INFO]
           [INFO] --- maven-resources-plugin:2.4.3:testResources (default-testResources) @ simple-heroku-webapp ---
           [INFO] Using 'UTF-8' encoding to copy filtered resources.
           [INFO] skip non existing resourceDirectory /tmp/build_992cc747-26d6-4800-bdb1-add47b9583cd/src/test/resources
           [INFO]
           [INFO] --- maven-compiler-plugin:2.5.1:testCompile (default-testCompile) @ simple-heroku-webapp ---
           [INFO] Compiling 1 source file to /tmp/build_992cc747-26d6-4800-bdb1-add47b9583cd/target/test-classes
           [INFO]
           [INFO] --- maven-surefire-plugin:2.7.2:test (default-test) @ simple-heroku-webapp ---
           [INFO] Tests are skipped.
           [INFO]
           [INFO] --- maven-war-plugin:2.1.1:war (default-war) @ simple-heroku-webapp ---
           [INFO] Packaging webapp
           [INFO] Assembling webapp [simple-heroku-webapp] in [/tmp/build_992cc747-26d6-4800-bdb1-add47b9583cd/target/simple-heroku-webapp]
           [INFO] Processing war project
           [INFO] Copying webapp resources [/tmp/build_992cc747-26d6-4800-bdb1-add47b9583cd/src/main/webapp]
           [INFO] Webapp assembled in [88 msecs]
           [INFO] Building war: /tmp/build_992cc747-26d6-4800-bdb1-add47b9583cd/target/simple-heroku-webapp.war
           [INFO] WEB-INF/web.xml already added, skipping
           [INFO]
           [INFO] --- maven-dependency-plugin:2.1:copy-dependencies (copy-dependencies) @ simple-heroku-webapp ---
           [INFO] Copying guava-14.0.1.jar to /tmp/build_992cc747-26d6-4800-bdb1-add47b9583cd/target/dependency/guava-14.0.1.jar
           [INFO] Copying javax.annotation-api-1.2.jar to /tmp/build_992cc747-26d6-4800-bdb1-add47b9583cd/target/dependency/javax.annotation-api-1.2.jar
           [INFO] Copying validation-api-1.1.0.Final.jar to /tmp/build_992cc747-26d6-4800-bdb1-add47b9583cd/target/dependency/validation-api-1.1.0.Final.jar
           [INFO] Copying javax.ws.rs-api-2.0.jar to /tmp/build_992cc747-26d6-4800-bdb1-add47b9583cd/target/dependency/javax.ws.rs-api-2.0.jar
           [INFO] Copying jetty-http-9.0.6.v20130930.jar to /tmp/build_992cc747-26d6-4800-bdb1-add47b9583cd/target/dependency/jetty-http-9.0.6.v20130930.jar
           [INFO] Copying jetty-io-9.0.6.v20130930.jar to /tmp/build_992cc747-26d6-4800-bdb1-add47b9583cd/target/dependency/jetty-io-9.0.6.v20130930.jar
           [INFO] Copying jetty-security-9.0.6.v20130930.jar to /tmp/build_992cc747-26d6-4800-bdb1-add47b9583cd/target/dependency/jetty-security-9.0.6.v20130930.jar
           [INFO] Copying jetty-server-9.0.6.v20130930.jar to /tmp/build_992cc747-26d6-4800-bdb1-add47b9583cd/target/dependency/jetty-server-9.0.6.v20130930.jar
           [INFO] Copying jetty-servlet-9.0.6.v20130930.jar to /tmp/build_992cc747-26d6-4800-bdb1-add47b9583cd/target/dependency/jetty-servlet-9.0.6.v20130930.jar
           [INFO] Copying jetty-util-9.0.6.v20130930.jar to /tmp/build_992cc747-26d6-4800-bdb1-add47b9583cd/target/dependency/jetty-util-9.0.6.v20130930.jar
           [INFO] Copying jetty-webapp-9.0.6.v20130930.jar to /tmp/build_992cc747-26d6-4800-bdb1-add47b9583cd/target/dependency/jetty-webapp-9.0.6.v20130930.jar
           [INFO] Copying jetty-xml-9.0.6.v20130930.jar to /tmp/build_992cc747-26d6-4800-bdb1-add47b9583cd/target/dependency/jetty-xml-9.0.6.v20130930.jar
           [INFO] Copying javax.servlet-3.0.0.v201112011016.jar to /tmp/build_992cc747-26d6-4800-bdb1-add47b9583cd/target/dependency/javax.servlet-3.0.0.v201112011016.jar
           [INFO] Copying hk2-api-2.2.0-b21.jar to /tmp/build_992cc747-26d6-4800-bdb1-add47b9583cd/target/dependency/hk2-api-2.2.0-b21.jar
           [INFO] Copying hk2-locator-2.2.0-b21.jar to /tmp/build_992cc747-26d6-4800-bdb1-add47b9583cd/target/dependency/hk2-locator-2.2.0-b21.jar
           [INFO] Copying hk2-utils-2.2.0-b21.jar to /tmp/build_992cc747-26d6-4800-bdb1-add47b9583cd/target/dependency/hk2-utils-2.2.0-b21.jar
           [INFO] Copying osgi-resource-locator-1.0.1.jar to /tmp/build_992cc747-26d6-4800-bdb1-add47b9583cd/target/dependency/osgi-resource-locator-1.0.1.jar
           [INFO] Copying asm-all-repackaged-2.2.0-b21.jar to /tmp/build_992cc747-26d6-4800-bdb1-add47b9583cd/target/dependency/asm-all-repackaged-2.2.0-b21.jar
           [INFO] Copying cglib-2.2.0-b21.jar to /tmp/build_992cc747-26d6-4800-bdb1-add47b9583cd/target/dependency/cglib-2.2.0-b21.jar
           [INFO] Copying javax.inject-2.2.0-b21.jar to /tmp/build_992cc747-26d6-4800-bdb1-add47b9583cd/target/dependency/javax.inject-2.2.0-b21.jar
           [INFO] Copying jersey-container-servlet-2.5.jar to /tmp/build_992cc747-26d6-4800-bdb1-add47b9583cd/target/dependency/jersey-container-servlet-2.5.jar
           [INFO] Copying jersey-container-servlet-core-2.5.jar to /tmp/build_992cc747-26d6-4800-bdb1-add47b9583cd/target/dependency/jersey-container-servlet-core-2.5.jar
           [INFO] Copying jersey-client-2.5.jar to /tmp/build_992cc747-26d6-4800-bdb1-add47b9583cd/target/dependency/jersey-client-2.5.jar
           [INFO] Copying jersey-common-2.5.jar to /tmp/build_992cc747-26d6-4800-bdb1-add47b9583cd/target/dependency/jersey-common-2.5.jar
           [INFO] Copying jersey-server-2.5.jar to /tmp/build_992cc747-26d6-4800-bdb1-add47b9583cd/target/dependency/jersey-server-2.5.jar
           [INFO]
           [INFO] --- maven-install-plugin:2.3.1:install (default-install) @ simple-heroku-webapp ---
           [INFO] Installing /tmp/build_992cc747-26d6-4800-bdb1-add47b9583cd/target/simple-heroku-webapp.war to /app/tmp/cache/.m2/repository/com/example/simple-heroku-webapp/1.0-SNAPSHOT/simple-heroku-webapp-1.0-SNAPSHOT.war
           [INFO] Installing /tmp/build_992cc747-26d6-4800-bdb1-add47b9583cd/pom.xml to /app/tmp/cache/.m2/repository/com/example/simple-heroku-webapp/1.0-SNAPSHOT/simple-heroku-webapp-1.0-SNAPSHOT.pom
           [INFO] ------------------------------------------------------------------------
           [INFO] BUILD SUCCESS
           [INFO] ------------------------------------------------------------------------
           [INFO] Total time: 45.861s
           [INFO] Finished at: Mon Dec 09 19:51:34 UTC 2013
           [INFO] Final Memory: 17M/514M
           [INFO] ------------------------------------------------------------------------
    -----> Discovering process types
           Procfile declares types -> web

    -----> Compiled slug size: 75.9MB
    -----> Launching... done, v6
           http://simple-heroku-webapp.herokuapp.com deployed to Heroku

    To git@heroku.com:simple-heroku-webapp.git
     * [new branch]      master -> master</screen>
            </para>
            <para>
                Now you can access your application at, for example: <link xlink:href='http://simple-heroku-webapp.herokuapp.com/myresource'>http://simple-heroku-webapp.herokuapp.com/myresource</link>
            </para>
        </section>
    </section>

    <section xml:id="exploring-jersey-examples">
        <title>Exploring Other Jersey Examples</title>
        <para>
            In the sections above, we have covered an approach how to get dirty with Jersey quickly. Please consult the other
            sections of the Jersey User Guide to learn more about Jersey and JAX-RS.
            Even though we try our best to cover as much as possible in the User Guide, there is always a chance that you would
            not be able to get a full answer to the problem you are solving. In that case, consider diving in our examples that
            provide additional tips and hints to the features you may want to use in your projects.
        </para>
        <para>
            Jersey codebase contains a number of useful examples on how to use various JAX-RS and Jersey features.
            Feel free to browse through the code of individual
            <link xlink:href="&jersey.github.examples.uri;">Jersey Examples</link> in the Jersey source repository.
            For off-line browsing, you can also download a bundle with all the examples from
            <link xlink:href="https://maven.java.net/content/repositories/&repository;/org/glassfish/jersey/bundles/jersey-examples/&version;/">here</link>.
        </para>
    </section>
</chapter>
