Author: buildbot
Date: Tue May 5 12:49:40 2015
New Revision: 950159
Log:
Staging update by buildbot for olingo
Modified:
websites/staging/olingo/trunk/content/ (props changed)
websites/staging/olingo/trunk/content/doc/odata4/tutorials/read/tutorial_read.html
Propchange: websites/staging/olingo/trunk/content/
------------------------------------------------------------------------------
--- cms:source-revision (original)
+++ cms:source-revision Tue May 5 12:49:40 2015
@@ -1 +1 @@
-1677588
+1677809
Modified:
websites/staging/olingo/trunk/content/doc/odata4/tutorials/read/tutorial_read.html
==============================================================================
---
websites/staging/olingo/trunk/content/doc/odata4/tutorials/read/tutorial_read.html
(original)
+++
websites/staging/olingo/trunk/content/doc/odata4/tutorials/read/tutorial_read.html
Tue May 5 12:49:40 2015
@@ -90,24 +90,24 @@
<p>This tutorial guides you through the steps required to write an OData
Service based on the Olingo OData 4.0 Library for Java (based on current
<em>Olingo 4.0.0-beta-02 release</em> which can be get via the <a
href="../../download.html">Download-Page</a>).</p>
<p>We will create a Web Application and deploy it on a local Tomcat server.
Afterwards, the OData service can be invoked from a browser and it will
provide the data according to the OData V4 specification.
-This tutorial is kept as minimalistic as possible, in order to fully
concentrate on the implementation of the service.
+This tutorial is kept as simple as possible, in order to fully concentrate on
the implementation of the service.
For example, only READ scenario is covered in this tutorial, whereas creation,
modification and deletion will be covered in the subsequent tutorial.</p>
<p><strong>Scenario</strong></p>
-<p>The OData service that weâre going to create will implement the following
model:</p>
+<p>The OData service that we are create will implement the following model:</p>
<p><img alt="datamodel" src="model1.png" title="The OData model" /></p>
<p>The service will display a list of products and a few properties that
describe each product.
This data model will be enhanced in the subsequent tutorials in order to
display Categories and to support navigation from a product to its Category.</p>
<p><strong>Goal</strong></p>
<p>We will be dealing with 3 java classes and the web.xml descriptor file.
-Furthermore, for building with maven, weâll edit the pom.xml file.</p>
-<p>This is how our working directory in Eclipse will look like:</p>
+Furthermore, for building with maven, we will edit the <code>pom.xml</code>
file.</p>
+<p>This is how our working directory in Eclipse will look:</p>
<p><img alt="projectLayout" src="EclipseProjectTree.png" title="The project
layout" /></p>
-<p>At the end of this tutorial, youâll have written an OData service and
youâll be able to invoke the following URL in a browser:</p>
+<p>At the end of this tutorial, you will have written an OData service and you
will be able to invoke the following URL in a browser:</p>
<div
class="codehilite"><pre>http://localhost:8080/DemoService/DemoService.svc/Products
</pre></div>
-<p>And the browser will display the following little collection of data:</p>
+<p>And the browser will display the following collection of data:</p>
<div class="codehilite"><pre><span class="p">{</span>
<span class="nt">"@odata.context"</span><span class="p">:</span>
<span class="s2">"$metadata#Products"</span><span class="p">,</span>
<span class="nt">"value"</span><span class="p">:</span> <span
class="p">[</span>
@@ -137,7 +137,7 @@ Furthermore, for building with maven, we
<li>Preparation</li>
<li>Create Project<ul>
<li>Create Project</li>
-<li>Edit pom file</li>
+<li>Edit <code>pom.xml</code> file</li>
<li>Check build path</li>
<li>Build the project</li>
</ul>
@@ -160,20 +160,21 @@ Furthermore, for building with maven, we
<p>In order to follow this tutorial, you should have</p>
<ul>
<li>Basic knowledge about OData and OData V4</li>
-<li>Knowledge about Java as programming language</li>
+<li>Knowledge of the Java programming language</li>
<li>Optional: knowledge about developing web applications</li>
<li>Optional: knowledge about building with Maven</li>
</ul>
<hr />
<h1 id="2-preparation">2. Preparation</h1>
-<p>Before starting off with the creation of our OData service, we need to
prepare for the following needs:</p>
+<p>Before starting off with the creation of our OData service, we need to
prepare the following:</p>
<ol>
+<li>Installed JDK 1.6 (or higher version)</li>
<li>An IDE for writing the Java code</li>
<li>A builder to build the .war file, which will be deployed on server</li>
<li>A web server to run our web application / OData service</li>
</ol>
<p>I recommend using Eclipse for all 3 needs, as it is the easiest approach.
-This means, you should install the pre-packed Eclipse distribution called
âEclipse IDE for Java EE developersâ and which can be found here:
http://www.eclipse.org/downloads/</p>
+This means, you should install the pre-packaged Eclipse distribution called
âEclipse IDE for Java EE developersâ which can be found here: <a
href="http://www.eclipse.org/downloads/";>http://www.eclipse.org/downloads/</a></p>
<p><img alt="eclipseDownload" src="eclipseDownload.png" title="The Eclipse EE
download" /></p>
<p>This Eclipse package contains an embedded server and also an integrated
Maven builder.</p>
<hr />
@@ -200,8 +201,8 @@ If youâre using this wizard for the
</blockquote>
<p>After finishing the wizard, the next step is to edit the <em>pom.xml</em>
file.</p>
<p><strong>Edit pom file</strong></p>
-<p>In our project, weâll be using several libraries, e.g. the Olingo
libraries.
-In the pom.xml file, we specify the dependencies and Maven will take care to
download them to our local maven repository.
+<p>In our project, we will be using several libraries, e.g. the Olingo
libraries.
+In the pom.xml file, we specify the dependencies and Maven will download them
to our local maven repository.
Furthermore, the <em>pom.xml</em> file tells Maven which output we want to
have as result of our build. In our case, this is a war file.</p>
<p>In our example, the pom.xml file looks as follows:</p>
<div class="codehilite"><pre><span class="nt"><project</span> <span
class="na">xmlns=</span><span
class="s">"http://maven.apache.org/POM/4.0.0"</span> <span
class="na">xmlns:xsi=</span><span
class="s">"http://www.w3.org/2001/XMLSchema-instance"</span>
@@ -267,7 +268,7 @@ Furthermore, the <em>pom.xml</em> file t
<em>Build Path -> Configure Build Pathâ¦</em></p>
<p><img alt="ConfigureBuildPathAction" src="ConfigureBuildPathAction.png"
title="Open the Configure BuildPath action" /></p>
<p>Select the <em>Source</em> tab.
-You might see that the source folder <em>src/main/java</em> is configured, but
marked with an error marker.</p>
+You might see that the source folder <em>src/main/java</em> is configured, but
displays an error marker.</p>
<p><img alt="ConfigureBuildPathErr" src="ConfigureBuildPathErr.png"
title="Configure BuildPath has errors" /></p>
<p>The reason is that it is missing on file system.
So the solution is to create the required folder in Eclipse.</p>
@@ -277,17 +278,16 @@ The second error might be about missing
Since we donât need it for our tutorial, we remove it from the build
path.</p>
<p><img alt="ConfigureBuildPathOK" src="ConfigureBuildPathOK.png"
title="Configure Build Path is OK now" /></p>
<p><strong>Build the project</strong></p>
-<p>Although the project doesnât contain any source files yet, letâs
perform our first Maven build, in order to check if there are any problems.</p>
-<p>From context menu on project node, chose <em>Run As -> maven build</em>
-If youâve never executed the build before, Maven asks you to specify at
least one goal.
+<p>Although the project doesnât contain any source files yet, letâs
perform our first Maven build, in order to check for any problems.</p>
+<p>From the context menu on the project node, chose <em>Run As -> maven
build</em>
+If you have never executed the build before, Maven asks you to specify at
least one goal.
Enter the usual goals âclean installâ and press âRunâ</p>
<p><img alt="mavenBuild" src="mavenBuild.png" title="The Maven build dialog"
/></p>
<p>The log output is provided in the Eclipse Console view.
You should check it for the output âBuild Successâ</p>
<blockquote>
<p>Note:
-It might be the case that maven provides an error marker right from the
beginning.
-In such case it helps to update your Project:
+If maven provides an error marker right from the beginning,it would help to
update your Project:
From context menu on project node, choose Maven -> update Project ->
<your project></p>
</blockquote>
<hr />
@@ -297,7 +297,7 @@ From context menu on project node, choos
<li>Declaring the metadata of the service</li>
<li>Handle service requests </li>
</ul>
-<p>Furthermore, since our example service has to run on a web server, we have
to create some code which allows to call our service in a web application: </p>
+<p>Since our example service has to run on a web server, we have to create
some code which calls our service in a web application: </p>
<ul>
<li>Web application implementation</li>
</ul>
@@ -319,7 +319,7 @@ Here, the user can see which Entity Coll
<p>The information that is given by these 2 URIs, has to be implemented in the
service code.
-Olingo provides API for it and weâll use it in the implementation of our
<em>EdmProvider.</em></p>
+Olingo provides API for it and we will use it in the implementation of our
<em>EdmProvider.</em></p>
<h3 id="412-create-class">4.1.2. Create class</h3>
<p>Create package <em>myservice.mynamespace.service</em><br />
Create class <em>DemoEdmProvider</em> and specify the superclass
<em>org.apache.olingo.server.api.edm.provider.EdmProvider</em></p>
@@ -354,8 +354,8 @@ These are:</p>
<p>In Eclipse, in order to select the methods to override, right click into
the Java editor and from the context menu choose <em>Source ->
Override/Implement Methodsâ¦</em>
Select the mentioned methods and press OK.</p>
<p><img alt="overrideMethods" src="overrideMethods.png" title="The dialog for
overriding superclass methods in Eclipse" /></p>
-<p>Letâs have a closer look at the methods in detail.</p>
-<p>First, we need to declare some constants, to be used in below code</p>
+<p>Letâs have a closer look at our methods in detail.</p>
+<p>First, we need to declare some constants, to be used in the code below:</p>
<div class="codehilite"><pre><span class="c1">// Service Namespace</span>
<span class="kd">public</span> <span class="kd">static</span> <span
class="kd">final</span> <span class="n">String</span> <span
class="n">NAMESPACE</span> <span class="o">=</span> <span
class="s">"com.example.model"</span><span class="o">;</span>
@@ -374,7 +374,7 @@ Select the mentioned methods and press O
<p><strong><em>getEntityType()</em></strong></p>
<p>In our example service, we want to provide a list of products to users who
call the OData service.
-The user of our service, for example an app-developer, will ask himself: how
does such a "product" entry look like? How is it structured? Which information
about a product is provided? For example, the name of it? And which data types
can be expected from these properties?<br />
+The user of our service, for example an app-developer, may ask: What does such
a "product" entry look like? How is it structured? Which information about a
product is provided? For example, the name of it and which data types can be
expected from these properties?<br />
Such information is provided by the <em>EdmProvider</em>.</p>
<p>In our example service, for modelling the <em>EntityType</em>, we have to
provide the following metadata:</p>
<p>The name of the EntityType: âProductâ<br />
@@ -412,12 +412,12 @@ Which of the properties is the âkey
<p><strong><em>getEntitySet()</em></strong></p>
<p>The procedure for declaring the <em>EntitySets</em> is similar.
An <em>EntitySet</em> is a crucial resource, when an OData service is used to
request data.
-In our example, weâll invoke the following URL, which we expect to provide
us a list of products:</p>
+In our example, we will invoke the following URL, which we expect to provide
us a list of products:</p>
<div
class="codehilite"><pre>http://localhost:8080/DemoService/DemoServlet.svc/Products
</pre></div>
-<p>When declaring an <em>EntitySet</em>, we need to define the type of entries
which are contained in the list. Such type is an <em>EntityType</em>.
+<p>When declaring an <em>EntitySet</em>, we need to define the type of entries
which are contained in the list, such as an <em>EntityType</em>.
In our example, we set our previously created <em>EntityType</em>, which is
referred by a <em>FullQualifiedName</em>.</p>
<div class="codehilite"><pre><span class="nd">@Override</span>
<span class="kd">public</span> <span class="n">EntitySet</span> <span
class="nf">getEntitySet</span><span class="o">(</span><span
class="n">FullQualifiedName</span> <span class="n">entityContainer</span><span
class="o">,</span> <span class="n">String</span> <span
class="n">entitySetName</span><span class="o">)</span> <span
class="kd">throws</span> <span class="n">ODataException</span> <span
class="o">{</span>
@@ -458,8 +458,8 @@ In our example, we have only one <em>Ent
<p><strong><em>getSchemas()</em></strong></p>
-<p>Up to this point, we have declared the type of our data
(<em>EntityType</em>) and our list (<em>EntitySet</em>), and weâve put it
into a container (<em>EntityContainer</em>).<br />
-Now weâre required to put all these elements into a <em>Schema</em>.<br />
+<p>Up to this point, we have declared the type of our data
(<em>EntityType</em>) and our list (<em>EntitySet</em>), and we have put it
into a container (<em>EntityContainer</em>).<br />
+Now we are required to put all these elements into a <em>Schema</em>.<br />
While the model of an OData service can have several schemas, in most cases
there will probably be only one schema.<br />
So, in our example, we create a list of schemas, where we add one new
<em>Schema</em> object.<br />
The schema is configured with a <em>Namespace</em>, which serves to uniquely
identify all elements.<br />
@@ -508,12 +508,8 @@ Then our elements are added to the Schem
We have created a class that declares the metadata of our OData service.
We have declared the main elements of an OData service: <em>EntityType</em>,
<em>EntitySet</em>, <em>EntityContainer</em> and <em>Schema</em>.</p>
<p>At runtime of an OData service, such metadata can be viewed by invoking the
Metadata Document.</p>
-<p>In our example invoke the URL:</p>
-<div
class="codehilite"><pre>http://localhost:8080/DemoService/DemoService.svc/$metadata
-</pre></div>
-
-
-<p>Give us this result:</p>
+<p>In our example invokation of the URL: <a
href="http://localhost:8080/DemoService/DemoService.svc/$metadata";>http://localhost:8080/DemoService/DemoService.svc/$metadata</a></p>
+<p>Give us the result below:</p>
<div class="codehilite"><pre><span class="cp"><?xml version='1.0'
encoding='UTF-8'?></span>
<span class="nt"><edmx:Edmx</span> <span class="na">Version=</span><span
class="s">"4.0"</span> <span class="na">xmlns:edmx=</span><span
class="s">"http://docs.oasis-open.org/odata/ns/edmx"</span><span
class="nt">></span>
<span class="nt"><edmx:DataServices></span>
@@ -535,12 +531,8 @@ We have declared the main elements of an
</pre></div>
-<p>The Service Document can be invoked to view the Entity Sets, like in our
example at</p>
-<div class="codehilite"><pre>http://localhost:8080/DemoService/DemoService.svc/
-</pre></div>
-
-
-<p>with give us this result:</p>
+<p>The Service Document can be invoked to view the Entity Sets, like in our
example at the URL: <a
href="http://localhost:8080/DemoService/DemoService.svc/";>http://localhost:8080/DemoService/DemoService.svc/</a></p>
+<p>Which give us the service document as result:</p>
<div class="codehilite"><pre><span class="p">{</span>
<span class="nt">"@odata.context"</span> <span class="p">:</span>
<span
class="s2">"http://localhost:8080/DemoService/DemoService.svc/$metadata"</span><span
class="p">,</span>
<span class="nt">"value"</span> <span class="p">:</span> <span
class="p">[</span>
@@ -556,7 +548,7 @@ We have declared the main elements of an
<p>Note:<br />
After implementing the <em>EdmProvider</em>, we can, as an intermediate step,
build/deploy the service and invoke the 2 static pages: service document and
metadata document.<br />
If desired, you can proceed with implementing the required steps for web
application as described in
-4.3. And run the application as described in chapter 5</p>
+4.3. and run the application as described in chapter 5.</p>
</blockquote>
<h2 id="42-provide-the-data">4.2. Provide the data</h2>
<p>After implementing the <em>EdmProvider</em>, the next step is the main task
of an OData service: provide data.<br />
@@ -571,19 +563,19 @@ Providing the list of products is the ta
3. Serialize the data<br />
The data has to be transformed into the required format
4. Configure the response<br />
- Since weâre implementing a âprocessorâ, the last step is to provide
the response object</p>
+ Since we are implementing a âprocessorâ, the last step is to provide
the response object</p>
<p>These 4 steps will be considered in the implementation of the
<em>readEntityCollection()</em> method.</p>
<h3 id="421-background">4.2.1. Background</h3>
<p>In terms of <em>Olingo</em>, while processing a service request, a
Processor instance is invoked that is supposed to understand the (user HTTP-)
request and deliver the desired data.<br />
<em>Olingo</em> provides API for processing different kind of service
requests:<br />
Such a service request can ask for a list of entities, or for one entity, or
one property.</p>
<p>Example:<br />
-In our example, weâve stated in our metadata document that weâll provide a
list of âproductsâ whenever the <em>EntitySet</em> with name âProductsâ
is invoked.<br />
+In our example, we have stated in our metadata document that We will provide a
list of âproductsâ whenever the <em>EntitySet</em> with name âProductsâ
is invoked.<br />
This means that the user of our OData service will append the
<em>EntitySet</em> name to the root URL of the service and then invoke the full
URL.<br />
This is http://localhost:8080/ExampleService1/ExampleServlet1.svc/Products
So, whenever this URL is fired, Olingo will invoke the
<em>EntityCollectionProcessor</em> implementation of our OData service.
-And our <em>EntityCollectionProcessor</em> implementation is expected to
provide a list of products.</p>
-<p>As weâve already mentioned, the metadata document is the contract for
providing data.
+Then our <em>EntityCollectionProcessor</em> implementation is expected to
provide a list of products.</p>
+<p>As we have already mentioned, the metadata document is the contract for
providing data.
This means that when it comes to provide the actual data, we have to do it
according to the specified metadata.<br />
For example, the property names have to match, also the types of the
properties, and, if specified, the length of the strings, etc</p>
<h3 id="422-create-class">4.2.2. Create class</h3>
@@ -593,16 +585,16 @@ For example, the property names have to
<p>After creation of the Java class, we can see that there are 2 methods to be
implemented:</p>
<ul>
<li><em>init()</em><br />
- This method is invoked by the <em>Olingo</em> Framework, allowing us to
store the context object</li>
+ This method is invoked by the <em>Olingo</em> library, allowing us to
store the context object</li>
<li><em>readEntityCollection()</em><br />
- Here we have to fetch the required data and pass it back to the
<em>Olingo</em> FWK</li>
+ Here we have to fetch the required data and pass it back to the
<em>Olingo</em> library</li>
</ul>
<p>Letâs have a closer look</p>
<p><strong><em>init()</em></strong></p>
<p>This method is common to all processor interfaces.<br />
The <em>Olingo</em> framework initializes the processor with an instance of
the <em>OData</em> object.
According to the Javadoc, this object is the âRoot object for serving
factory tasksâ¦â
-Weâll need it later, so we store it as member variable.</p>
+We will need it later, so we store it as member variable.</p>
<div class="codehilite"><pre><span class="kd">public</span> <span
class="kt">void</span> <span class="nf">init</span><span
class="o">(</span><span class="n">OData</span> <span
class="n">odata</span><span class="o">,</span> <span
class="n">ServiceMetadata</span> <span class="n">serviceMetadata</span><span
class="o">)</span> <span class="o">{</span>
<span class="k">this</span><span class="o">.</span><span
class="na">odata</span> <span class="o">=</span> <span
class="n">odata</span><span class="o">;</span>
<span class="o">}</span>
@@ -645,7 +637,7 @@ In this case as well, our readEntityColl
<p><strong>Note:</strong>
If the user doesnât specify any content type, then the default is JSON.</p>
<p>Why is this parameter needed?<br />
-Because the <em>readEntityCollection</em> method is supposed to deliver the
data in the format that is requested by the user. Weâll use this parameter
when creating a serializer based on it.</p>
+Because the <em>readEntityCollection</em> method is supposed to deliver the
data in the format that is requested by the user. We will use this parameter
when creating a serializer based on it.</p>
<p>The steps for implementating the method <em>readEntityCollection</em>
are:</p>
<ol>
<li>
@@ -661,7 +653,7 @@ Because the <em>readEntityCollection</em
</li>
<li>
<p>Transform the data<br />
-<em>Olingo</em> expects from us to provide the data as low-level
<em>InputStream</em> object. However, <em>Olingo</em> supports us in doing so,
by providing us with a proper "serializer".
+<em>Olingo</em> expects us to provide the data as low-level
<em>InputStream</em> object. However, <em>Olingo</em> supports us in doing so,
by providing us with a proper "serializer".
So what we have to do is create the serializer based on the requested
content type, configure it and call it.</p>
</li>
<li>
@@ -705,9 +697,9 @@ Because the <em>readEntityCollection</em
<p><strong><em>getData()</em></strong></p>
-<p>Up to now, we havenât elaborated on fetching the actual data.
+<p>We have not elaborated on fetching the actual data.
In our tutorial, to keep the code as simple as possible, we use a little
helper method that delivers some hardcoded entries.<br />
-Since weâre supposed to deliver the data inside an <em>EntitySet</em>
instance, we create the instance, ask it for the (initially empty) list of
entities and add some new entities to it.<br />
+Since we are supposed to deliver the data inside an <em>EntitySet</em>
instance, we create the instance, ask it for the (initially empty) list of
entities and add some new entities to it.<br />
We create the entities and their properties according to what we declared in
our <em>ExampleEdmProvider</em> class. So we have to take care to provide the
correct names to the new property objects.</p>
<div class="codehilite"><pre><span class="kd">private</span> <span
class="n">EntitySet</span> <span class="nf">getData</span><span
class="o">(</span><span class="n">EdmEntitySet</span> <span
class="n">edmEntitySet</span><span class="o">){</span>
@@ -737,7 +729,7 @@ We create the entities and their propert
<h2 id="43-web-application">4.3. Web Application</h2>
<p>After declaring the metadata and providing the data, our OData service
implementation is done.<br />
The last step is to enable our OData service to be called on a web server.<br
/>
-Therefore, weâre wrapping our service by a web application.</p>
+Therefore, we are wrapping our service by a web application.</p>
<p>The web application is defined in the web.xml file, where a servlet is
registered.
The servlet is a standard <em>HttpServlet</em> which dispatches the user
requests to the <em>Olingo</em> framework.</p>
<p>Letâs quickly do the remaining steps:</p>
@@ -746,11 +738,11 @@ The servlet is a standard <em>HttpServle
Create Java class with name <em>DemoServlet</em> that inherits from
<em>HttpServlet</em>.</p>
<p><img alt="createJavaServletClass" src="createJavaServletClass.png"
title="Creating the servlet class" /></p>
<p>Override the <code>service()</code> method.<br />
-Basically, what weâre doing here is to create an <em>ODataHttpHandler</em>,
which is a class that is provided by <em>Olingo</em>.
+Basically, what we are doing here is to create an <em>ODataHttpHandler</em>,
which is a class that is provided by <em>Olingo</em>.
It receives the user request and if the URL conforms to the OData
specification, the request is delegated to the processor implementation of the
OData service.
This means that the handler has to be configured with all processor
implementations that have been created along with the OData service (in our
example, only one processor).
Furthermore, the <code>ODataHttpHandler</code> needs to carry the knowledge
about the <code>EdmProvider</code>.</p>
-<p>As such, hereâs the location where our 2 implemented classes come
together, the metadata declaration and the data provisioning.</p>
+<p>This is where our two implemented classes come together, the metadata
declaration and the data provisioning.</p>
<div class="codehilite"><pre><span class="c1">// This class represents a
standard HttpServlet implementation.</span>
<span class="c1">// It is used as main entry point for the web application
that carries the OData service.</span>
<span class="c1">// The implementation of this HttpServlet simply delegates
the user requests to the ODataHttpHandler</span>
@@ -809,20 +801,24 @@ Furthermore, we need to specify the <em>
<hr />
<h1 id="5-run-the-service">5. Run the service</h1>
<p>Running the service means build the war file and deploy it on a server.<br
/>
-In our tutorial, weâre using the Eclipse web integration tools, which make
life easier.</p>
+In our tutorial, we are using the Eclipse web integration tools, which make
life easier.</p>
<h3 id="run-with-eclipse">Run with Eclipse</h3>
<p>Select your project and from the context menu choose <em>Run As -> Run
on Server</em><br />
If you donât have any server configured in Eclipse, you have to âmanually
define a new serverâ in the subsequent dialog.<br />
If you have installed a Tomcat server on your local file system, you can use
it here.<br />
If not, you can use the <em>Basic -> J2EE Preview</em> option, which is
should be enough for our tutorial. </p>
<p><img alt="runOnServer" src="runOnServer.png" title="The Eclipse dialog for
deploying web apps to a server" /></p>
-<p><strong>Note:</strong>
+<blockquote>
+<p>Note:
You might have to first execute maven build and also press F5 to refresh the
content of the Eclipse project</p>
+</blockquote>
<p>After pressing "run", Eclipse starts the internal server and deploys the
web application on it.
Then the Eclipse internal Browser View is opened and the index.jsp file that
has been generated into our Example project is opened.<br />
We ignore it. Instead, we open our OData service in our favorite browser.</p>
-<p><strong>Note:</strong>
+<blockquote>
+<p>Note:
If you face problems related to the server, it helps to restart your Eclipse
IDE.</p>
+</blockquote>
<h3 id="the-service-urls">The service-URLs</h3>
<p>Try the following URLs:</p>
<p><strong>Service Document</strong></p>
@@ -899,7 +895,7 @@ If you face problems related to the serv
<hr />
<h1 id="6-summary">6. Summary</h1>
-<p>Finally, weâve created our first OData service based on the V4 version of
the OData specification and using the V4 server library provided by
<em>Olingo</em>.<br />
+<p>Finally, we have created our first OData service based on the V4 version of
the OData specification and using the V4 server library provided by
<em>Olingo</em>.<br />
Our first OData service is very simple; it only allows invoking one entity
collection, apart from the service document and the metadata document.</p>
<p><strong>Outlook</strong></p>
<p>Further topics to be covered by follow-up tutorials: </p>
