<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
    <head>
        <title>Apache Wink : 4 JAX-RS Concepts</title>
	    <link rel="stylesheet" href="styles/site.css" type="text/css" />
        <META http-equiv="Content-Type" content="text/html; charset=UTF-8">	    
    </head>

    <body>
	    <table class="pagecontent" border="0" cellpadding="0" cellspacing="0" width="100%" bgcolor="#ffffff">
		    <tr>
			    <td valign="top" class="pagebody">
				    <div class="pageheader">
					    <span class="pagetitle">
                            Apache Wink : 4 JAX-RS Concepts
                                                    </span>
				    </div>
				    <div class="pagesubheading">
					    This page last changed on Sep 16, 2009 by <font color="#0050B2">michael</font>.
				    </div>

				    <h1><a name="4JAX-RSConcepts-JAXRSConcepts"></a>JAX-RS Concepts</h1>

<p>JAX-RS (JSR 311) is the latest JCP specification that provides a Java based API for REST Web services over the HTTP protocol. The JAX-RS specification is an annotation based server side API.</p>

<h2><a name="4JAX-RSConcepts-ApplyingJAXRStoApacheWink"></a>Applying JAX-RS to Apache Wink</h2>

<p><a href="http://incubator.apache.org/wink/">Apache Wink</a> is a full implementation of the JAX-RS 1.0 specification, providing a rich set of features and expansions that extend and supplement the JAX-RS specification. Apache Wink is designed to be an easy to use, production quality and efficient implementation.</p>

<p>The Apache Wink architecture enables the incorporation of custom functionality via the use of handlers that provide for the manipulation of requests, Apache Wink also provides a powerful client module for the consumption of REST web services and is bundled with a range of built-in Providers that enable the developer to quickly implement applications that make use of industry standard formats such as XML, ATOM, APP, RSS, JSON, CSV, HTML.</p>

<h3><a name="4JAX-RSConcepts-DevelopingRESTApplications"></a>Developing REST Applications</h3>

<p>For those new to JAX-RS or developing REST applications, follow this in-progress developer guide.  If you have comments or questions, send an e-mail to the appropriate <a href="http://cwiki.apache.org/confluence/display/WINK/Index" title="Index">Apache Wink mailing lists</a>.</p>

<p>While this developer guide covers common scenarios, it is not intended to detail the JAX-RS specification itself.  Please read the (brief yet understandable) specification if it is available to you.</p>

<h2><a name="4JAX-RSConcepts-GettingStartedASimpleJAXRSApplicationJAXRSGettingStarted"></a><a href="JAX-RS Getting Started.html" title="JAX-RS Getting Started">Getting Started - A Simple JAX-RS Application</a></h2>

<ul>
	<li>Creating a Resource</li>
	<li>Creating a javax.ws.rs.core.Application sub-class</li>
	<li>Packaging Apache Wink with a Web Application</li>
	<li>Installation and Running the Application</li>
</ul>


<h2><a name="4JAX-RSConcepts-ApplicationConfigurationJAXRSApplicationConfiguration"></a><a href="JAX-RS Application Configuration.html" title="JAX-RS Application Configuration">Application Configuration</a></h2>

<ul>
	<li>javax.ws.rs.core.Application subclass</li>
	<li>Container environment information</li>
</ul>


<h2><a name="4JAX-RSConcepts-Resources%2CHTTPMethods%2CandPathsJAXRSResources%2CHTTPMethods%2CandPaths"></a><a href="JAX-RS Resources, HTTP Methods, and Paths.html" title="JAX-RS Resources, HTTP Methods, and Paths">Resources, HTTP Methods, and Paths</a></h2>

<ul>
	<li><a href="JAX-RS Resources, HTTP Methods, and Paths.html#JAX-RSResources%2CHTTPMethods%2CandPaths-RootResource">Root Resource Methods</a></li>
	<li><a href="JAX-RS Resources, HTTP Methods, and Paths.html#JAX-RSResources%2CHTTPMethods%2CandPaths-javax.ws.rs.core.Response">javax.ws.rs.core.Response</a></li>
	<li><a href="JAX-RS Resources, HTTP Methods, and Paths.html#JAX-RSResources%2CHTTPMethods%2CandPaths-HTTPMethods">HTTP Methods</a></li>
	<li><a href="JAX-RS Resources, HTTP Methods, and Paths.html#JAX-RSResources%2CHTTPMethods%2CandPaths-SubresourceMethod">Subresource Methods</a></li>
	<li><a href="JAX-RS Resources, HTTP Methods, and Paths.html#JAX-RSResources%2CHTTPMethods%2CandPaths-SubresourceLocator">Subresource Locators</a></li>
	<li>Regular Expressions</li>
</ul>


<h2><a name="4JAX-RSConcepts-RequestandResponseEntities%28MessageBodies%29andMediaTypesJAXRSRequestandResponseEntities"></a><a href="JAX-RS Request and Response Entities.html" title="JAX-RS Request and Response Entities">Request and Response Entities (Message Bodies) and Media Types</a></h2>

<ul>
	<li><a href="JAX-RS Request and Response Entities.html#JAX-RSRequestandResponseEntities-ConsumesAndProduces">Produces/Consumes annotations</a></li>
	<li>ATOM</li>
	<li>XML</li>
	<li>JSON</li>
	<li><a href="JAX-RS Request and Response Entities.html#JAX-RSRequestandResponseEntities-JAXRSStandardEntityProviders">Standard Entity Parameter Types</a></li>
	<li>Custom application provided Message Body Readers/Writers</li>
	<li><a href="JAX-RS Request and Response Entities.html#JAX-RSRequestandResponseEntities-TransferEncoding">Transfer Encoding</a></li>
	<li><a href="JAX-RS Request and Response Entities.html#JAX-RSRequestandResponseEntities-ContentEncoding">Content Encoding</a></li>
</ul>


<h2><a name="4JAX-RSConcepts-ParametersJAXRSParameters"></a><a href="JAX-RS Parameters.html" title="JAX-RS Parameters">Parameters</a></h2>

<ul>
	<li><a href="JAX-RS Parameters.html#JAX-RSParameters-QueryParameter">Query Parameters</a></li>
	<li><a href="JAX-RS Parameters.html#JAX-RSParameters-PathParameter">Path Parameters</a></li>
	<li><a href="JAX-RS Parameters.html#JAX-RSParameters-MatrixParameter">Matrix Parameters</a></li>
	<li><a href="JAX-RS Parameters.html#JAX-RSParameters-HeaderParameter">Header Parameters</a></li>
	<li><a href="JAX-RS Parameters.html#JAX-RSParameters-CookieParameter">Cookie Parameters</a></li>
</ul>


<h2><a name="4JAX-RSConcepts-HTTPHeadersJAXRSHTTPHeaders"></a><a href="JAX-RS HTTP Headers.html" title="JAX-RS HTTP Headers">HTTP Headers</a></h2>

<ul>
	<li><a href="JAX-RS HTTP Headers.html#JAX-RSHTTPHeaders-RequestHeaders">Common HTTP Request Headers</a></li>
	<li><a href="JAX-RS HTTP Headers.html#JAX-RSHTTPHeaders-ResponseHeaders">Common HTTP Response Headers</a></li>
</ul>


<h2><a name="4JAX-RSConcepts-ContentNegotiationJAXRSContentNegotiation"></a><a href="JAX-RS Content Negotiation.html" title="JAX-RS Content Negotiation">Content Negotiation</a></h2>

<ul>
	<li><a href="JAX-RS Content Negotiation.html#JAX-RSContentNegotiation-URL">Using URIs to identify content type</a></li>
	<li><a href="JAX-RS Content Negotiation.html#JAX-RSContentNegotiation-Parameter">Using parameters to identify content type</a></li>
	<li><a href="JAX-RS Content Negotiation.html#JAX-RSContentNegotiation-AcceptHeader">Using Accept headers</a></li>
</ul>


<h2><a name="4JAX-RSConcepts-UsingRequestContextInformationJAXRSContextInformation"></a><a href="JAX-RS Context Information.html" title="JAX-RS Context Information">Using Request Context Information</a></h2>

<ul>
	<li><a href="JAX-RS Context Information.html#JAX-RSContextInformation-HttpHeaders">HTTP Headers</a></li>
	<li><a href="JAX-RS Context Information.html#JAX-RSContextInformation-UriInfo">URI Information</a></li>
	<li><a href="JAX-RS Context Information.html#JAX-RSContextInformation-SecurityContext">Security Information</a></li>
	<li><a href="JAX-RS Context Information.html#JAX-RSContextInformation-Request">Request</a></li>
	<li><a href="JAX-RS Context Information.html#JAX-RSContextInformation-Providers">Providers</a></li>
</ul>


<h2><a name="4JAX-RSConcepts-CachingJAXRSCaching"></a><a href="JAX-RS Caching.html" title="JAX-RS Caching">Caching</a></h2>

<ul>
	<li>Expires</li>
	<li>Cache-Control</li>
</ul>


				    
                    			    </td>
		    </tr>
	    </table>
	    <table border="0" cellpadding="0" cellspacing="0" width="100%">
			<tr>
				<td height="12" background="http://cwiki.apache.org/confluence/images/border/border_bottom.gif"><img src="images/border/spacer.gif" width="1" height="1" border="0"/></td>
			</tr>
		    <tr>
			    <td align="center"><font color="grey">Document generated by Confluence on Nov 11, 2009 06:57</font></td>
		    </tr>
	    </table>
    </body>
</html>