atom.xml

<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">

  <title><![CDATA[Contrast Of Beauty]]></title>
  <link href="http://blackat.github.io/atom.xml" rel="self"/>
  <link href="http://blackat.github.io/"/>
  <updated>2016-09-11T13:07:12+02:00</updated>
  <id>http://blackat.github.io/</id>
  <author>
    <name><![CDATA[black@t]]></name>
    
  </author>
  <generator uri="http://octopress.org/">Octopress</generator>

  
  <entry>
    <title type="html"><![CDATA[Furure of Declaration Files]]></title>
    <link href="http://blackat.github.io/blog/2016/09/11/furure-of-declaration-files/"/>
    <updated>2016-09-11T11:15:37+02:00</updated>
    <id>http://blackat.github.io/blog/2016/09/11/furure-of-declaration-files</id>
    <content type="html"><![CDATA[<p>When I have started to use TypeScript I have looked at <a href="http://definitelytyped.org/">Definitely Typed</a> to see how many  people where writing declaration files (<code>.d.ts</code>) and then <a href="https://typescript.codeplex.com/wikipage?title=Writing%20Definition%20%28.d.ts%29%20Files">guidelines from Microsoft</a> to see how to do it. There was then the utility <a href="https://github.com/DefinitelyTyped/tsd">tsd</a>, but now many stuff has changed.</p>

<!-- more -->


<h2>Evolution at Glance</h2>

<h3>TSD Package Manager</h3>

<blockquote><p>TSD is a package manager to search and install TypeScript definition files directly from the community driven DefinitelyTyped repository.</p><footer><strong>DefinitelyTyped</strong> <cite><a href='https://github.com/DefinitelyTyped/tsd'>TSD</a></cite></footer></blockquote>


<p>A tool has to be installed via <code>npm</code> to fetch the package and start to configure a file named <code>tsd.json</code> that holds all the declaration (or definition) files. Basically <code>tsd</code> is like <code>npm</code> with similar commands able to manage defintion dependencies used by TypeScript compiler to transpile <code>.ts</code> files and by type guard to perform runtime check.</p>

<blockquote><p>A type guard is some expression that performs a runtime check that guarantees the type in some scope.</p><footer><strong>TypeScript</strong> <cite><a href='https://www.typescriptlang.org/docs/handbook/advanced-types.html'>Documentation</a></cite></footer></blockquote>


<h3>Typings</h3>

<p>Some months go, looking at the <a href="https://github.com/DefinitelyTyped/tsd">GitHub repository</a>, I have discovered <a href="https://github.com/DefinitelyTyped/tsd/issues/269">the project has been deprecated</a> in favor of <a href="https://github.com/typings/typings">typings</a>. So <code>typings</code> is an evolution of <code>tsd</code> with some advantages explained <a href="https://github.com/typings/typings/issues/72">here</a> by <a href="https://github.com/blakeembrey">blakeembrey</a>.</p>

<p>Basically the previous tool has been improved into a more generic package manager that acts like <code>npm</code>, then it still requires to be installed. Old projects have to be updated to migrate from <code>tsd</code> if previously used. Slighter different syntax needs to be learnt.</p>

<h3>@Types</h3>

<p>Recently I was experimenting <a href="https://github.com/angular/angular-cli">Angular2 Command Line Interface</a> and I have noticed that generating a new project the folder <code>typings</code> was not created, something missing? Not at all, TypeScript 2.0 has improved once again and a new property <code>types</code> has been kicked in the <code>tsconfig.json</code>.</p>

<p>So looking at the <code>tsconfig.json</code> <a href="http://json.schemastore.org/tsconfig">schema definition</a> we can find</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
</pre></td><td class='code'><pre><code class='json'><span class='line'><span class="err">types:</span> <span class="p">{</span>
</span><span class='line'>  <span class="nt">&quot;description&quot;</span><span class="p">:</span> <span class="s2">&quot;Type declaration files to be included in compilation. Requires TypeScript version 2.0 or later.&quot;</span><span class="p">,</span>
</span><span class='line'>  <span class="nt">&quot;type&quot;</span><span class="p">:</span> <span class="s2">&quot;array&quot;</span><span class="p">,</span>
</span><span class='line'>  <span class="nt">&quot;items&quot;</span><span class="p">:</span> <span class="p">{</span>
</span><span class='line'>    <span class="nt">&quot;type&quot;</span><span class="p">:</span> <span class="s2">&quot;string&quot;</span>
</span><span class='line'>  <span class="p">}</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>The evolution is explained in this post from <a href="https://blogs.msdn.microsoft.com/typescript/2016/06/15/the-future-of-declaration-files/">Daniel Rosenwasser</a> Program Manager on TypeScript.</p>

<p>In a nutshell</p>

<blockquote><p>Getting type declarations in TypeScript 2.0 will require no tools apart from npm.</p><footer><strong>Daniel Rosenwasser</strong> <cite><a href='https://blogs.msdn.microsoft.com/typescript/2016/06/15/the-future-of-declaration-files'>The Future of Declaration Files</a></cite></footer></blockquote>


<p>Really a good news! we can rid off some extra entities in our project such as:</p>

<ul>
<li>another package managers then <code>npm</code>;</li>
<li><code>json</code> file for type declarations;</li>
<li>configure <code>tsconfig.json</code> to exclude files from <code>typings</code> folder;</li>
<li>the famous <code>///reference</code> at the beginning of each <code>.ts</code> file.</li>
</ul>


<h4>Usage</h4>

<p>Very simple:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
</pre></td><td class='code'><pre><code class='bash'><span class='line'>npm install --save @types/lodash
</span></code></pre></td></tr></table></div></figure>




<blockquote><p>From there you’ll be able to use lodash in your TypeScript code with no fuss. This works for both modules and global code.</p><footer><strong>Daniel Rosenwasser</strong> <cite><a href='https://blogs.msdn.microsoft.com/typescript/2016/06/15/the-future-of-declaration-files'>The Future of Declaration Files</a></cite></footer></blockquote>


<p>No more additional configuration or references at the beginning of each file.</p>

<h4>Type Search</h4>

<p>Please refer to <a href="http://microsoft.github.io/TypeSearch/">TypeSearch</a> search engine to find a type definition and how to install it via <code>npm</code>.</p>

<p>At first sight I could say the project is cleaner, less utilities and, may be, a more consistent way to manage <code>.d.ts</code> files. I hope a definitive path has been defined (at least for a couple of years) in order to have all the dependencies centralized in one place.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[How to Test 2: TDD a Simple Example]]></title>
    <link href="http://blackat.github.io/blog/2015/03/21/how-to-test-2-tdd-a-simple-example/"/>
    <updated>2015-03-21T12:37:14+01:00</updated>
    <id>http://blackat.github.io/blog/2015/03/21/how-to-test-2-tdd-a-simple-example</id>
    <content type="html"><![CDATA[<p>Test Driven Development (TDD) is a software development process based on the <em>test-first</em> approach of <a href="http://en.wikipedia.org/wiki/Extreme_programming">extreme programming</a>. Roughly the idea is creating tests before any implementation and then start development guided by test, finally refactor. We will quickly explore the technique and its <em>rhythm</em> to highlight advantages and disadvantages. <strong>DRAFT 1</strong></p>

<!-- more  -->


<h3>Components and material</h3>

<p>This tutorial is part of an experiment done to simply explain fundamental concepts of testing. In the <a href="http://blackat.github.io/blog/2015/03/07/how-to-test-1-find-errors-to-make-the-application-works/">previous one</a> you can find concepts and jargon of the testing world along with some exercises which can help you to get in confidence with unit testing and mock objects. The code experiment used in this tutorial is described in the previous article and can be found on <a href="https://github.com/blackat/tutorial-howtotest-1-collectors">GitHub</a>, so please clone it to experiment or just follow some code snippet on this page.</p>

<h2>A bit of theory</h2>

<h2>Learning by example</h2>

<p>Imagine to write a new collector unit which can be plugged into the Cloud Service. At the beginning not all the details are clear and well defined, but with some imagination we can define some functionalities. Just a sort of rough idea and then start to apply the TDD steps one by one.</p>

<h3>First test</h3>

<h5>RED</h5>

<p>So let&rsquo;s create the <code>FacebookCollectorTddTest.class</code> and implement the first</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">FacebookCollectorTddTest</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="nd">@Test</span>
</span><span class='line'>    <span class="kd">public</span> <span class="kt">void</span> <span class="nf">testAcceptGoldenPath</span><span class="o">()</span> <span class="kd">throws</span> <span class="n">Exception</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>        <span class="n">FacebookCollector</span> <span class="n">collector</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">FacebookCollector</span><span class="o">();</span>
</span><span class='line'>        <span class="n">assertTrue</span><span class="o">(</span><span class="n">collector</span><span class="o">.</span><span class="na">accept</span><span class="o">(</span><span class="k">new</span> <span class="nf">FacebookPost</span><span class="o">(</span><span class="s">&quot;Just a foo post&quot;</span><span class="o">),</span> <span class="mi">1L</span><span class="o">));</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>the code won&rsquo;t compile because the classes still do not exist. You can ask your IDE to implement the classes for you. For instance in <a href="https://www.jetbrains.com/idea/">IntelliJ IDEA</a> you can exploit the class creation functionality as the screenshot below
<img class="center" src="http://blackat.github.io/images/posts/idea_class_creation.png"></p>

<p>The class we are going to implement should implement the <code>Collector.java</code> interface</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">FacebookCollector</span> <span class="kd">implements</span> <span class="n">Collector</span> <span class="o">{</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>The <code>Collector</code> interface is already the result of some rough idea about the service, but can be improved or extended in orde to support new features or requirements.</p>

<p>Once the code compile, run the test and make it fails, <strong>Red</strong>. But wait a minute! The assertion does not have any message and when the test fails does not tell us anything interesting.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="n">java</span><span class="o">.</span><span class="na">lang</span><span class="o">.</span><span class="na">AssertionError</span>
</span><span class='line'>  <span class="n">at</span> <span class="n">org</span><span class="o">.</span><span class="na">junit</span><span class="o">.</span><span class="na">Assert</span><span class="o">.</span><span class="na">fail</span><span class="o">(</span><span class="n">Assert</span><span class="o">.</span><span class="na">java</span><span class="o">:</span><span class="mi">86</span><span class="o">)</span>
</span><span class='line'>  <span class="n">at</span> <span class="n">org</span><span class="o">.</span><span class="na">junit</span><span class="o">.</span><span class="na">Assert</span><span class="o">.</span><span class="na">assertTrue</span><span class="o">(</span><span class="n">Assert</span><span class="o">.</span><span class="na">java</span><span class="o">:</span><span class="mi">41</span><span class="o">)</span>
</span><span class='line'>  <span class="n">at</span> <span class="n">org</span><span class="o">.</span><span class="na">junit</span><span class="o">.</span><span class="na">Assert</span><span class="o">.</span><span class="na">assertTrue</span><span class="o">(</span><span class="n">Assert</span><span class="o">.</span><span class="na">java</span><span class="o">:</span><span class="mi">52</span><span class="o">)</span>
</span><span class='line'>  <span class="n">at</span> <span class="n">com</span><span class="o">.</span><span class="na">contrastofbeauty</span><span class="o">.</span><span class="na">tutorial</span><span class="o">.</span><span class="na">collectors</span><span class="o">.</span><span class="na">FacebookCollectorTddTest</span><span class="o">.</span><span class="na">testAcceptGoldenPath</span><span class="o">(</span><span class="n">FacebookCollectorTddTest</span><span class="o">.</span><span class="na">java</span><span class="o">:</span><span class="mi">15</span><span class="o">)</span>
</span></code></pre></td></tr></table></div></figure>


<p>Let&rsquo;s improve the assertion with a test message</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="nd">@Test</span>
</span><span class='line'><span class="kd">public</span> <span class="kt">void</span> <span class="nf">testAcceptGoldenPath</span><span class="o">()</span> <span class="kd">throws</span> <span class="n">Exception</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">FacebookCollector</span> <span class="n">collector</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">FacebookCollector</span><span class="o">();</span>
</span><span class='line'>    <span class="n">FacebookPost</span> <span class="n">facebookPost</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">FacebookPost</span><span class="o">(</span><span class="s">&quot;Just a foo post&quot;</span><span class="o">);</span>
</span><span class='line'>    <span class="n">assertTrue</span><span class="o">(</span><span class="s">&quot;Object &quot;</span> <span class="o">+</span> <span class="n">facebookPost</span> <span class="o">+</span> <span class="s">&quot; for user &quot;</span> <span class="o">+</span> <span class="n">USER_ID</span> <span class="o">+</span> <span class="s">&quot; has not been accepted.&quot;</span><span class="o">,</span> <span class="n">collector</span><span class="o">.</span><span class="na">accept</span><span class="o">(</span><span class="n">facebookPost</span><span class="o">,</span> <span class="n">USER_ID</span><span class="o">));</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<h5>GREEN</h5>

<p>Make the test passes with the minimum and simplest amount of code. As result the <em>first version</em> of the constructor and the <code>accept</code> method could be</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">FacebookCollector</span> <span class="kd">implements</span> <span class="n">Collector</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'><span class="kd">private</span> <span class="n">Map</span><span class="o">&lt;</span><span class="n">Long</span><span class="o">,</span> <span class="n">List</span><span class="o">&lt;</span><span class="n">FacebookPost</span><span class="o">&gt;&gt;</span> <span class="n">facebookPostMap</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'><span class="kd">public</span> <span class="nf">FacebookCollector</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>    <span class="n">facebookPostMap</span> <span class="o">=</span> <span class="k">new</span> <span class="n">HashMap</span><span class="o">&lt;&gt;();</span>
</span><span class='line'><span class="o">}</span>
</span><span class='line'>
</span><span class='line'><span class="nd">@Override</span>
</span><span class='line'><span class="kd">public</span> <span class="kt">boolean</span> <span class="nf">accept</span><span class="o">(</span><span class="n">Object</span> <span class="n">object</span><span class="o">,</span> <span class="kt">long</span> <span class="n">userId</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">if</span><span class="o">(</span><span class="n">facebookPostMap</span><span class="o">.</span><span class="na">get</span><span class="o">(</span><span class="n">userId</span><span class="o">)</span> <span class="o">==</span> <span class="kc">null</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>        <span class="n">facebookPostMap</span><span class="o">.</span><span class="na">put</span><span class="o">(</span><span class="n">userId</span><span class="o">,</span> <span class="k">new</span> <span class="n">ArrayList</span><span class="o">&lt;</span><span class="n">FacebookPost</span><span class="o">&gt;());</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">facebookPostMap</span><span class="o">.</span><span class="na">get</span><span class="o">(</span><span class="n">userId</span><span class="o">).</span><span class="na">add</span><span class="o">((</span><span class="n">FacebookPost</span><span class="o">)</span> <span class="n">object</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">return</span> <span class="kc">true</span><span class="o">;</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>Now re-running the test it passes. Comparing this way of implementing with the one seen to correct the class by testing you can notice we have some quite a good amount of time because of <code>NullPointerException</code>, they have been spotted immediately and corrected without allowing them to propagate.</p>

<h5>REFACTOR</h5>

<p>Refactor both test and the class to make them more readable such as the <code>setUp()</code> method, the assertion message and the constant</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">FacebookCollectorTddTest</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">private</span> <span class="kd">static</span> <span class="kd">final</span> <span class="kt">long</span> <span class="n">USER_ID</span> <span class="o">=</span> <span class="mi">1L</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">private</span> <span class="n">FacebookCollector</span> <span class="n">collector</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">private</span> <span class="n">FacebookPost</span> <span class="n">facebookPost</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>    <span class="nd">@Before</span>
</span><span class='line'>    <span class="kd">public</span> <span class="kt">void</span> <span class="nf">setUp</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>        <span class="n">collector</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">FacebookCollector</span><span class="o">();</span>
</span><span class='line'>        <span class="n">facebookPost</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">FacebookPost</span><span class="o">(</span><span class="s">&quot;Just a foo post&quot;</span><span class="o">);</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="nd">@Test</span>
</span><span class='line'>    <span class="kd">public</span> <span class="kt">void</span> <span class="nf">testAcceptGoldenPath</span><span class="o">()</span> <span class="kd">throws</span> <span class="n">Exception</span> <span class="o">{</span>
</span><span class='line'>        <span class="n">String</span> <span class="n">message</span> <span class="o">=</span> <span class="s">&quot;Object &quot;</span> <span class="o">+</span> <span class="n">facebookPost</span> <span class="o">+</span> <span class="s">&quot; for user &quot;</span> <span class="o">+</span> <span class="n">USER_ID</span> <span class="o">+</span> <span class="s">&quot; has not been accepted.&quot;</span><span class="o">;</span>
</span><span class='line'>        <span class="n">assertTrue</span><span class="o">(</span><span class="n">message</span><span class="o">,</span> <span class="n">collector</span><span class="o">.</span><span class="na">accept</span><span class="o">(</span><span class="n">facebookPost</span><span class="o">,</span> <span class="n">USER_ID</span><span class="o">));</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<hr />

<h3>Second test</h3>

<h5>RED</h5>

<p>The test is marked as <em>GoldenPath</em> in order to highlight it is the most common case, where everything should run smooth. But what happens at the borders? Our implementation always return true except when an exception happens. So let&rsquo;s implement another test.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="nd">@Test</span>
</span><span class='line'><span class="kd">public</span> <span class="kt">void</span> <span class="nf">testAcceptWrongObjectType</span><span class="o">()</span> <span class="kd">throws</span> <span class="n">Exception</span> <span class="o">{</span>
</span><span class='line'>    <span class="n">Integer</span> <span class="n">fooObject</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">Integer</span><span class="o">(</span><span class="mi">123</span><span class="o">);</span>
</span><span class='line'>    <span class="n">String</span> <span class="n">message</span> <span class="o">=</span> <span class="s">&quot;Object &quot;</span> <span class="o">+</span> <span class="n">fooObject</span> <span class="o">+</span> <span class="s">&quot; for user &quot;</span> <span class="o">+</span> <span class="n">USER_ID</span> <span class="o">+</span> <span class="s">&quot; must not be accepted.&quot;</span><span class="o">;</span>
</span><span class='line'>    <span class="n">assertFalse</span><span class="o">(</span><span class="n">message</span><span class="o">,</span> <span class="n">collector</span><span class="o">.</span><span class="na">accept</span><span class="o">(</span><span class="n">fooObject</span><span class="o">,</span> <span class="n">USER_ID</span><span class="o">));</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>The test will fail because of a <code>java.lang.ClassCastException</code>, the declaration of the list <code>List&lt;FacebookPost&gt;</code> prevents some wrong addition to the list.</p>

<h5>GREEN</h5>

<p>It is enough doing a check on the type of object to make the test passes</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="nd">@Override</span>
</span><span class='line'><span class="kd">public</span> <span class="kt">boolean</span> <span class="nf">accept</span><span class="o">(</span><span class="n">Object</span> <span class="n">object</span><span class="o">,</span> <span class="kt">long</span> <span class="n">userId</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">if</span> <span class="o">(</span><span class="n">object</span> <span class="k">instanceof</span> <span class="n">FacebookPost</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>        <span class="k">if</span> <span class="o">(</span><span class="n">facebookPostMap</span><span class="o">.</span><span class="na">get</span><span class="o">(</span><span class="n">userId</span><span class="o">)</span> <span class="o">==</span> <span class="kc">null</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>            <span class="n">facebookPostMap</span><span class="o">.</span><span class="na">put</span><span class="o">(</span><span class="n">userId</span><span class="o">,</span> <span class="k">new</span> <span class="n">ArrayList</span><span class="o">&lt;</span><span class="n">FacebookPost</span><span class="o">&gt;());</span>
</span><span class='line'>        <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>        <span class="n">facebookPostMap</span><span class="o">.</span><span class="na">get</span><span class="o">(</span><span class="n">userId</span><span class="o">).</span><span class="na">add</span><span class="o">((</span><span class="n">FacebookPost</span><span class="o">)</span> <span class="n">object</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>            <span class="k">return</span> <span class="kc">true</span><span class="o">;</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">return</span> <span class="kc">false</span><span class="o">;</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<h5>REFACTOR</h5>

<p>Test and class should be fine.</p>

<hr />

<h3>Third test</h3>

<p>Roughly a collector starts to collect posts from a user, when a certain number of posts is reached, the collector calls the method <code>flush()</code> to submit the job.</p>

<h5>RED</h5>

<p>Let&rsquo;s write a failing test</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="nd">@Test</span>
</span><span class='line'><span class="kd">public</span> <span class="kt">void</span> <span class="nf">testAcceptCallFlushMethod</span><span class="o">()</span> <span class="kd">throws</span> <span class="n">Exception</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">collector</span><span class="o">.</span><span class="na">setNewBufferSize</span><span class="o">(</span><span class="mi">2</span><span class="o">);</span>
</span><span class='line'>    <span class="n">collector</span><span class="o">.</span><span class="na">setCallbackFunction</span><span class="o">(</span><span class="n">callbackMock</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">collector</span><span class="o">.</span><span class="na">accept</span><span class="o">(</span><span class="n">facebookPost</span><span class="o">,</span> <span class="n">USER_ID</span><span class="o">);</span>
</span><span class='line'>    <span class="n">collector</span><span class="o">.</span><span class="na">accept</span><span class="o">(</span><span class="n">facebookPost</span><span class="o">,</span> <span class="n">USER_ID</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">verify</span><span class="o">(</span><span class="n">callbackMock</span><span class="o">,</span> <span class="n">times</span><span class="o">(</span><span class="mi">1</span><span class="o">)).</span><span class="na">addTask</span><span class="o">(</span><span class="n">any</span><span class="o">(</span><span class="n">Callable</span><span class="o">.</span><span class="na">class</span><span class="o">),</span> <span class="n">anyInt</span><span class="o">());</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>The test sets the <em>buffer size</em> equal to two so it is enough adding two posts to have the <code>flush</code> method called. By using Mockito it is possible to verify if a certain method has been called and how many times. This is <em>behavior verification</em> and happens on <em>indirect outputs</em>.</p>

<h5>GREEN</h5>

<p>A solution for the method could be</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
<span class='line-number'>26</span>
<span class='line-number'>27</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="nd">@Override</span>
</span><span class='line'><span class="kd">public</span> <span class="kt">boolean</span> <span class="nf">accept</span><span class="o">(</span><span class="n">Object</span> <span class="n">object</span><span class="o">,</span> <span class="kt">long</span> <span class="n">userId</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">if</span> <span class="o">(</span><span class="n">object</span> <span class="k">instanceof</span> <span class="n">FacebookPost</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>            <span class="k">if</span> <span class="o">(</span><span class="n">facebookPostMap</span><span class="o">.</span><span class="na">get</span><span class="o">(</span><span class="n">userId</span><span class="o">)</span> <span class="o">==</span> <span class="kc">null</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>                <span class="n">facebookPostMap</span><span class="o">.</span><span class="na">put</span><span class="o">(</span><span class="n">userId</span><span class="o">,</span> <span class="k">new</span> <span class="n">ArrayList</span><span class="o">&lt;</span><span class="n">FacebookPost</span><span class="o">&gt;());</span>
</span><span class='line'>            <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>        <span class="n">facebookPostMap</span><span class="o">.</span><span class="na">get</span><span class="o">(</span><span class="n">userId</span><span class="o">).</span><span class="na">add</span><span class="o">((</span><span class="n">FacebookPost</span><span class="o">)</span> <span class="n">object</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>        <span class="k">if</span> <span class="o">(</span><span class="n">newBufferSize</span> <span class="o">!=</span> <span class="mi">0</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>            <span class="k">if</span> <span class="o">(</span><span class="n">facebookPostMap</span><span class="o">.</span><span class="na">get</span><span class="o">(</span><span class="n">userId</span><span class="o">).</span><span class="na">size</span><span class="o">()</span> <span class="o">==</span> <span class="n">newBufferSize</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>                <span class="n">flush</span><span class="o">(</span><span class="n">userId</span><span class="o">);</span>
</span><span class='line'>            <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>        <span class="o">}</span> <span class="k">else</span> <span class="o">{</span>
</span><span class='line'>            <span class="k">if</span> <span class="o">(</span><span class="n">facebookPostMap</span><span class="o">.</span><span class="na">get</span><span class="o">(</span><span class="n">userId</span><span class="o">).</span><span class="na">size</span><span class="o">()</span> <span class="o">==</span> <span class="n">BUFFER_SIZE</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>                <span class="n">flush</span><span class="o">(</span><span class="n">userId</span><span class="o">);</span>
</span><span class='line'>            <span class="o">}</span>
</span><span class='line'>        <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>        <span class="k">return</span> <span class="kc">true</span><span class="o">;</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">return</span> <span class="kc">false</span><span class="o">;</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p> To make the test work we have to implement other three methods such as <code>flush()</code>, <code>setNewBufferSize()</code> and setCallbackFunction(). SO it is possible to temporary move to other tests and then come back or just provide a fake implementation to produce the call of the method we want to verify. It depends a lot on experience, confidence with the task and how strict we want to adhere to TDD approach. Two methods are setters and they should not be tested, the third one could be temporary implemented as</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="nd">@Override</span>
</span><span class='line'><span class="kd">public</span> <span class="kt">void</span> <span class="nf">flush</span><span class="o">(</span><span class="kt">long</span> <span class="n">userId</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">callbackFunction</span><span class="o">.</span><span class="na">addTask</span><span class="o">(</span><span class="k">new</span> <span class="nf">Callable</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>        <span class="nd">@Override</span>
</span><span class='line'>        <span class="kd">public</span> <span class="n">Object</span> <span class="nf">call</span><span class="o">()</span> <span class="kd">throws</span> <span class="n">Exception</span> <span class="o">{</span>
</span><span class='line'>            <span class="k">return</span> <span class="kc">null</span><span class="o">;</span>
</span><span class='line'>        <span class="o">}</span>
</span><span class='line'>    <span class="o">},</span> <span class="n">userId</span><span class="o">);</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>The test passes.</p>

<h5>REFACTOR</h5>

<p>Improve a bit the <code>accept()</code> method to make it more readable and compact. One solution could be</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="nd">@Override</span>
</span><span class='line'><span class="kd">public</span> <span class="kt">boolean</span> <span class="nf">accept</span><span class="o">(</span><span class="n">Object</span> <span class="n">object</span><span class="o">,</span> <span class="kt">long</span> <span class="n">userId</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">if</span> <span class="o">(</span><span class="n">object</span> <span class="k">instanceof</span> <span class="n">FacebookPost</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>         <span class="k">if</span> <span class="o">(</span><span class="n">facebookPostMap</span><span class="o">.</span><span class="na">get</span><span class="o">(</span><span class="n">userId</span><span class="o">)</span> <span class="o">==</span> <span class="kc">null</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>             <span class="n">facebookPostMap</span><span class="o">.</span><span class="na">put</span><span class="o">(</span><span class="n">userId</span><span class="o">,</span> <span class="k">new</span> <span class="n">ArrayList</span><span class="o">&lt;</span><span class="n">FacebookPost</span><span class="o">&gt;());</span>
</span><span class='line'>         <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>         <span class="n">facebookPostMap</span><span class="o">.</span><span class="na">get</span><span class="o">(</span><span class="n">userId</span><span class="o">).</span><span class="na">add</span><span class="o">((</span><span class="n">FacebookPost</span><span class="o">)</span> <span class="n">object</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>         <span class="kt">int</span> <span class="n">bufferSize</span> <span class="o">=</span> <span class="n">newBufferSize</span> <span class="o">!=</span> <span class="mi">0</span> <span class="o">?</span> <span class="n">newBufferSize</span> <span class="o">:</span> <span class="n">BUFFER_SIZE</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>         <span class="k">if</span> <span class="o">(</span><span class="n">facebookPostMap</span><span class="o">.</span><span class="na">get</span><span class="o">(</span><span class="n">userId</span><span class="o">).</span><span class="na">size</span><span class="o">()</span> <span class="o">==</span> <span class="n">bufferSize</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>             <span class="n">flush</span><span class="o">(</span><span class="n">userId</span><span class="o">);</span>
</span><span class='line'>         <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>         <span class="k">return</span> <span class="kc">true</span><span class="o">;</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">return</span> <span class="kc">false</span><span class="o">;</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<hr />

<h3>Fourth test</h3>

<p>It&rsquo;s time to test the <code>flush()</code> method. Write a unit test, make it fails and re-implement it in a more appropriate way than what done before.
When the <code>flush()</code> method is called, it creates a task and invokes a method against a callback function, the list for a given user is cleared.</p>

<h5>RED</h5>

<p>The failing test</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="nd">@Test</span>
</span><span class='line'><span class="kd">public</span> <span class="kt">void</span> <span class="nf">testFlushGoldenPath</span><span class="o">()</span> <span class="kd">throws</span> <span class="n">Exception</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">collector</span><span class="o">.</span><span class="na">setCallbackFunction</span><span class="o">(</span><span class="n">callbackMock</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">collector</span><span class="o">.</span><span class="na">accept</span><span class="o">(</span><span class="n">facebookPost</span><span class="o">,</span> <span class="n">USER_ID</span><span class="o">);</span>
</span><span class='line'>    <span class="n">collector</span><span class="o">.</span><span class="na">accept</span><span class="o">(</span><span class="n">facebookPost</span><span class="o">,</span> <span class="n">USER_ID</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">String</span> <span class="n">message1</span> <span class="o">=</span> <span class="s">&quot;The list size for the user &quot;</span> <span class="o">+</span> <span class="n">USER_ID</span> <span class="o">+</span> <span class="s">&quot; must be equal to 2&quot;</span><span class="o">;</span>
</span><span class='line'>    <span class="n">assertEquals</span><span class="o">(</span><span class="n">message1</span><span class="o">,</span> <span class="mi">2</span><span class="o">,</span> <span class="n">collector</span><span class="o">.</span><span class="na">getListSizeByUserId</span><span class="o">(</span><span class="n">USER_ID</span><span class="o">));</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">collector</span><span class="o">.</span><span class="na">flush</span><span class="o">(</span><span class="n">USER_ID</span><span class="o">);</span>
</span><span class='line'>    <span class="n">String</span> <span class="n">message2</span> <span class="o">=</span> <span class="s">&quot;The list size after a call to flush() must be 0&quot;</span><span class="o">;</span>
</span><span class='line'>    <span class="n">assertEquals</span><span class="o">(</span><span class="n">message2</span><span class="o">,</span> <span class="mi">0</span><span class="o">,</span> <span class="n">collector</span><span class="o">.</span><span class="na">getListSizeByUserId</span><span class="o">(</span><span class="n">USER_ID</span><span class="o">));</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">verify</span><span class="o">(</span><span class="n">callbackMock</span><span class="o">,</span> <span class="n">times</span><span class="o">(</span><span class="mi">1</span><span class="o">)).</span><span class="na">addTask</span><span class="o">(</span><span class="n">any</span><span class="o">(</span><span class="n">Callable</span><span class="o">.</span><span class="na">class</span><span class="o">),</span> <span class="n">anyInt</span><span class="o">());</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>We test</p>

<pre><code>- posts have been correctly added
- after the call to the `flush()` method the list is empty
- the method `addTask()` from callback is invoked
</code></pre>

<h5>GREEN</h5>

<p>Solution</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="nd">@Override</span>
</span><span class='line'><span class="kd">public</span> <span class="kt">void</span> <span class="nf">flush</span><span class="o">(</span><span class="kt">long</span> <span class="n">userId</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">List</span><span class="o">&lt;</span><span class="n">FacebookPost</span><span class="o">&gt;</span> <span class="n">list</span> <span class="o">=</span> <span class="k">new</span> <span class="n">ArrayList</span><span class="o">&lt;&gt;(</span><span class="n">facebookPostMap</span><span class="o">.</span><span class="na">get</span><span class="o">(</span><span class="n">userId</span><span class="o">));</span>
</span><span class='line'>    <span class="n">facebookPostMap</span><span class="o">.</span><span class="na">get</span><span class="o">(</span><span class="n">userId</span><span class="o">).</span><span class="na">clear</span><span class="o">();</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">FacebookTask</span> <span class="n">facebookTask</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">FacebookTask</span><span class="o">(</span><span class="n">list</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">callbackFunction</span><span class="o">.</span><span class="na">addTask</span><span class="o">(</span><span class="n">facebookTask</span><span class="o">,</span> <span class="n">userId</span><span class="o">);</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>The test run fine.</p>

<h5>REFACTOR</h5>

<p>The class seems fine.</p>

<hr />

<h3>Fifth test</h3>

<p>Add exception in case the callback function is not set. This is a borderline test</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[How to Test 1: Find Errors to Make the Application Works]]></title>
    <link href="http://blackat.github.io/blog/2015/03/07/how-to-test-1-find-errors-to-make-the-application-works/"/>
    <updated>2015-03-07T09:37:33+01:00</updated>
    <id>http://blackat.github.io/blog/2015/03/07/how-to-test-1-find-errors-to-make-the-application-works</id>
    <content type="html"><![CDATA[<p>This is an <em>experiment tutorial</em> to better learn some <em>101</em> practices and how testing can be a better replacement of developing by debugging.</p>

<p>The goal of the <em>experiment-project</em> is to find, to correct bugs and make the application works by writing tests.</p>

<!-- more -->


<h2>A bit of theory and jargon</h2>

<p><em>SUT:</em> the System Under Test, in a unit test it could be a <em>class</em>.</p>

<p><em>Test class:</em> the <em>client</em> of the interface exposed by the SUT.</p>

<p><em>test fixture:</em> the context under which a test is run, it is a baseline under which running tests. It is a set of operations to bring the <em>System Under Test (SUT)</em> in a given state, run the test and verify the <em>expected outcome</em>. Test fixture and the expected outcome are tightly coupled, the test fixture allows the test to be repeatable for ever and ever. Method <code>setUp()</code> or <code>initialization</code> is used to create fixture while <code>tearDown()</code> or <code>distruction</code> is invoked to restore the original state.</p>

<p>A test has four phases:</p>

<ol>
<li><strong>set up</strong> to <em>apply</em> the test fixture;</li>
<li><strong>exercise</strong> to <em>interact</em> with the API exposed by the SUT;</li>
<li><strong>verifiy</strong> to check if the expected outcome has been <em>matched</em>;</li>
<li><strong>tear down</strong> to return to the <em>original state</em> tearing down the test fixture.</li>
</ol>


<h2>Clone the project</h2>

<p>Clone the project from <a href="https://github.com/blackat/tutorial-howtotest-1-collectors">Github</a> and import it in you preferred IDE, <a href="https://www.jetbrains.com/idea/">IntelliJ IDEA</a> in my case.</p>

<h3>Project Structure</h3>

<pre><code>├── README.md
├── exercise-api
│   ├── pom.xml
│   └── src
│       └── main
│           └── java
│               └── com
│                   └── contrastofbeauty
│                       └── tutorial
│                           └── api
│                               ├── collectors
│                               │   └── Collector.java
│                               ├── domain
│                               │   ├── AcknoledgeService.java
│                               │   └── Callback.java
│                               └── services
│                                   └── Service.java
├── exercise-to-be-corrected
│   ├── pom.xml
│   └── src
│       ...
│
├── exercise-working
│   ├── pom.xml
│   └── src
│       ...
│
└── pom.xml
</code></pre>

<p>The maven project is composed by four modules:</p>

<ol>
<li><strong>exercise-api:</strong> just collection of interfaces used in the other two modules;</li>
<li><strong>exercise-working:</strong> working application with a test suite;</li>
<li><strong>exercise-to-be-corrected:</strong> application with bugs where the test suite has to be created in order to find, correct bugs and make it work;</li>
<li><strong>exercise-tdd:</strong> implementation of some classes by tdd whose description is in the next <a href="http://blackat.github.io/blog/2015/03/21/how-to-test-2-tdd-a-simple-example">tut</a>.</li>
</ol>


<p>In the module <code>exercise-to-be-corrected</code> run the class <code>RunMeToBeCorrected.java</code> and see that it fails some some reason, may be a <code>NullPointerException</code> is thrown. We do not care so much because we do not want to make it work by a common pattern <strong>running/debugging</strong> rather we want to <em>implement missing tests</em> demonstrating how they can help us to find and correct bug make our application more robust.</p>

<h2>Application Description</h2>

<p>The application is mainly composed by a fake <a href="https://github.com/blackat/tutorial-howtotest-1-collectors/blob/master/exercise-working/src/main/java/com/contrastofbeauty/tutorial/services/CloudService.java">Cloud Service</a> able to post user&rsquo;s tweets in batch by means of a <a href="https://github.com/blackat/tutorial-howtotest-1-collectors/blob/master/exercise-working/src/main/java/com/contrastofbeauty/tutorial/collectors/TweetCollector.java">Tweet Collector</a>. <a href="http://yuml.me/edit/3555184c">Here</a> the UML source.</p>

<p><img class="center" src="http://blackat.github.io/images/posts/tutorial_1_how_to_test.png"></p>

<h3>The workflow</h3>

<ol>
<li>The <code>CloudService</code> <em>has a</em> certain numbers of different type collectors (hence the association in the UML diagram), in this case just with one able to collect tweets.</li>
<li>A user who wants to post tweet in batch has to open a connection invoking the method <code>service.openConnection()</code> of the service.</li>
<li>The user then starts to post tweets using the method <code>service.saveObject()</code>.</li>
<li>Once done <code>service.saveObjectCompleted()</code> method will be called to tell the service that the user session is finished.</li>
</ol>


<h4>The workflow in details</h4>

<ol>
<li>The <code>CloudService</code> <em>has a</em> <code>TweetCollector</code> and a <code>Callback</code> implementation instance (Another approach is to leave the service the initialization of the callback function and substitute the <em>association</em> with a <em>composition</em> in the UML diagram).</li>
<li>The <code>Callback</code> implementation instance will be set into each added collector by the service.</li>
<li>Every time a user wants to save a tweet through the service, the collector will stock it in a <em>list</em> as a sort of buffer.</li>
<li>Once the collector has stocked a certain amount of tweets, for instance 500, it will generates a <em>task</em>.</li>
<li>A task has a collection of tweets and the implementation of the method <code>call()</code> which will be called by one of the thread of the thread pool. The method specifies how the list of tweets should be treated, for instance: saved, destroyed, sent to Twitter, printed or something else.</li>
<li>A collector uses the <code>Callback</code> instance to add a task to a <em>processing list</em>.</li>
<li>The list of active tasks will be then processed by a thread pool.</li>
</ol>


<h3>How to initiliaze the service and run it</h3>

<figure class='code'><figcaption><span>RunMeWorking.java</span> — <a href='https://github.com/blackat/tutorial-howtotest-1-collectors/blob/master/exercise-working/src/main/java/com/contrastofbeauty/tutorial/RunMeWorking.java'>Link</a></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">RunMeWorking</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">public</span> <span class="kd">static</span> <span class="kt">void</span> <span class="nf">main</span><span class="o">(</span><span class="n">String</span><span class="o">[]</span> <span class="n">args</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>        <span class="n">Callback</span> <span class="n">callback</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">CallbackImpl</span><span class="o">();</span>
</span><span class='line'>        <span class="n">Service</span> <span class="n">service</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">CloudService</span><span class="o">(</span><span class="n">callback</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>        <span class="n">service</span><span class="o">.</span><span class="na">addCollector</span><span class="o">(</span><span class="k">new</span> <span class="nf">TweetCollector</span><span class="o">());</span>
</span><span class='line'>
</span><span class='line'>        <span class="n">service</span><span class="o">.</span><span class="na">openConnection</span><span class="o">(</span><span class="mi">1L</span><span class="o">);</span>
</span><span class='line'>        <span class="n">service</span><span class="o">.</span><span class="na">saveObject</span><span class="o">(</span><span class="k">new</span> <span class="nf">Tweet</span><span class="o">(</span><span class="s">&quot;I am Felix the awesome cat.&quot;</span><span class="o">),</span> <span class="mi">1L</span><span class="o">);</span>
</span><span class='line'>        <span class="n">service</span><span class="o">.</span><span class="na">saveObjectCompleted</span><span class="o">(</span><span class="k">new</span> <span class="nf">AcknoledgeServiceImpl</span><span class="o">(),</span> <span class="mi">1L</span><span class="o">);</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p><strong>Actually</strong> the service does not post anything to Twitter, it is just a way to show a bit of java concurrency and how to write <em>unit tests</em> when dealing with concurrent structures like <code>Future</code>.</p>

<h2>Let&rsquo;s correct the application</h2>

<p>Let&rsquo;s create tests for the application starting from <code>TweetCollector.java</code> class, press <code>cmd + shift + T</code> on Mac or <code>crtl + shift + T</code> on Windows and choose methods you want to test, then Idea will create the test class in the right place</p>

<pre><code>src/test/java/com/contrastofbeauty/tutorial/collectors/TweetCollectorTest.java.
</code></pre>

<p><strong>Tip</strong> Make sure the path <code>src/test/java</code> exists, otherwise Idea will create the test class together with the source one.</p>

<p><img class="center" src="http://blackat.github.io/images/posts/idea-test-wizard.png"></p>

<h3>TweetCollector Class</h3>

<p><img class="center" src="http://blackat.github.io/images/posts/tweet-collector.png"></p>

<p><a href="https://github.com/blackat/tutorial-howtotest-1-collectors/blob/master/exercise-to-be-corrected/src/main/java/com/contrastofbeauty/tutorial/collectors/TweetCollector.java">TweetCollector</a> is specific implementation of <code>Collector</code> interface able to stores an object of a specific type in a <code>List</code> by <code>userId</code> when its method <code>accept()</code> is invoked (e.g. by the service cloud).</p>

<p>Once the tweet collector has collected a certain number of tweet objects, <code>flush()</code> method is called, a <code>TweetTask</code> object is created and passed an parameter to <code>callbackFunction.addTask()</code>. The task in then put in a queue to be processed. A task is a computation unit, it owns:</p>

<ul>
<li><code>call()</code> method: called by a thread when the task is available in the task queue;</li>
<li>processing list: a set of object on which the aforementioned method will work.</li>
</ul>


<p>Once the task is added to the queue the list is emptied, ready to accept new object to be processed.</p>

<h3>TweeterCollectorTest</h3>

<p>Populate the <code>setUp()</code> method creating a new <code>TweetCollector</code> and annotate it with <code>@Before</code> in order to get it run automatically before any method annotated with <code>@Test</code> as specfied by <a href="http://junit.sourceforge.net/javadoc/org/junit/Before.html">JUnit doc</a>. Evrytime a test method is run, the <code>setUp()</code> method is invoked to have a fresh and clean collector object.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">TweetCollectorTest</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">private</span> <span class="n">Collector</span> <span class="n">collector</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>    <span class="nd">@Before</span>
</span><span class='line'>    <span class="kd">public</span> <span class="kt">void</span> <span class="nf">setUp</span><span class="o">()</span> <span class="kd">throws</span> <span class="n">Exception</span> <span class="o">{</span>
</span><span class='line'>        <span class="n">collector</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">TweetCollector</span><span class="o">();</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<h4>Method accept() - 3 errors</h4>

<p>Let&rsquo;s start working on the method <code>accept(Object object, long userId)</code>. Create, or rename the method if already created by the IDE, <code>testAcceptGoldenPath()</code> and add the following assertion:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="nd">@Test</span>
</span><span class='line'><span class="kd">public</span> <span class="kt">void</span> <span class="nf">testAcceptGoldenPath</span><span class="o">()</span> <span class="kd">throws</span> <span class="n">Exception</span> <span class="o">{</span>
</span><span class='line'>    <span class="n">assertTrue</span><span class="o">(</span><span class="n">collector</span><span class="o">.</span><span class="na">accept</span><span class="o">(</span><span class="k">new</span> <span class="nf">Tweet</span><span class="o">(</span><span class="s">&quot;foo tweet&quot;</span><span class="o">),</span> <span class="mi">1L</span><span class="o">));</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>In the first test we want to test the <em>standard scenario</em> when everything run smooth, no exceptional situations. So for this reason it has been added the suffix <em>GoldenPath</em>, an alternative to <a href="http://en.wikipedia.org/wiki/Happy_path">Happy Path</a>. After that some borderline scenario tests will be added. <em>So run the test!</em></p>

<h5>Error 1</h5>

<p><strong>Issue:</strong> a <code>NullPointerException</code> is thrown.</p>

<p><strong>Solution:</strong> the object <code>processingList</code> has not been initialized. Add the initialization in the constructor for instance and <em>rerun the test</em>.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="nf">TweetCollector</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>    <span class="n">processingList</span> <span class="o">=</span> <span class="k">new</span> <span class="n">HashMap</span><span class="o">&lt;&gt;();</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<h5>Error 2</h5>

<p><strong>Issue:</strong> another <code>NullPointerException</code> is thrown because the data structure is accessed but not initialized for a given user:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="n">processingList</span><span class="o">.</span><span class="na">get</span><span class="o">(</span><span class="n">userId</span><span class="o">).</span><span class="na">add</span><span class="o">((</span><span class="n">Tweet</span><span class="o">)</span> <span class="n">object</span><span class="o">);</span>
</span></code></pre></td></tr></table></div></figure>


<p><strong>Solution:</strong> check if a given <code>userId</code> already exists in the map, if not create and add to the map the pair and <em>rerun the test</em>.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="k">if</span> <span class="o">(</span><span class="n">processingList</span><span class="o">.</span><span class="na">get</span><span class="o">(</span><span class="n">userId</span><span class="o">)</span> <span class="o">==</span> <span class="kc">null</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>    <span class="n">processingList</span><span class="o">.</span><span class="na">put</span><span class="o">(</span><span class="n">userId</span><span class="o">,</span> <span class="k">new</span> <span class="n">ArrayList</span><span class="o">&lt;</span><span class="n">Tweet</span><span class="o">&gt;());</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<h5>Error 3</h5>

<p><strong>Issue:</strong> an <code>AssertionError</code> is thrown. All the <code>NPE</code> have been fixed but it seems the collector has not accepted the <code>Tweet</code> object.</p>

<p><strong>Solution:</strong> a missing <code>return true</code> prevent the method to behave correctly. Add the aforementioned statement and <em>rerun the test</em>. Now the test passes and this is the complete code for the method <code>accept</code>:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="nd">@Override</span>
</span><span class='line'><span class="kd">public</span> <span class="kt">boolean</span> <span class="nf">accept</span><span class="o">(</span><span class="n">Object</span> <span class="n">object</span><span class="o">,</span> <span class="kt">long</span> <span class="n">userId</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">if</span> <span class="o">(</span><span class="n">object</span> <span class="k">instanceof</span> <span class="n">Tweet</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>        <span class="k">if</span> <span class="o">(</span><span class="n">processingList</span><span class="o">.</span><span class="na">get</span><span class="o">(</span><span class="n">userId</span><span class="o">)</span> <span class="o">==</span> <span class="kc">null</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>            <span class="n">processingList</span><span class="o">.</span><span class="na">put</span><span class="o">(</span><span class="n">userId</span><span class="o">,</span> <span class="k">new</span> <span class="n">ArrayList</span><span class="o">&lt;</span><span class="n">Tweet</span><span class="o">&gt;());</span>
</span><span class='line'>        <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>        <span class="n">processingList</span><span class="o">.</span><span class="na">get</span><span class="o">(</span><span class="n">userId</span><span class="o">).</span><span class="na">add</span><span class="o">((</span><span class="n">Tweet</span><span class="o">)</span> <span class="n">object</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>        <span class="k">if</span> <span class="o">(</span><span class="n">customBufferSize</span> <span class="o">!=</span> <span class="mi">0</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>            <span class="k">if</span> <span class="o">(</span><span class="n">processingList</span><span class="o">.</span><span class="na">get</span><span class="o">(</span><span class="n">userId</span><span class="o">).</span><span class="na">size</span><span class="o">()</span> <span class="o">==</span> <span class="n">customBufferSize</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>                <span class="n">flush</span><span class="o">(</span><span class="n">userId</span><span class="o">);</span>
</span><span class='line'>            <span class="o">}</span>
</span><span class='line'>        <span class="o">}</span> <span class="k">else</span> <span class="nf">if</span> <span class="o">(</span><span class="n">processingList</span><span class="o">.</span><span class="na">get</span><span class="o">(</span><span class="n">userId</span><span class="o">).</span><span class="na">size</span><span class="o">()</span> <span class="o">==</span> <span class="n">PROCESSING_LIST_BUFFER_SIZE</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>            <span class="n">flush</span><span class="o">(</span><span class="n">userId</span><span class="o">);</span>
</span><span class='line'>        <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>        <span class="k">return</span> <span class="kc">true</span><span class="o">;</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="k">return</span> <span class="kc">false</span><span class="o">;</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<h5>Additional tests</h5>

<p>The method now seems correct but has been tested in case of a different obejcts? Add a new test method which will be part of the <em>automatic test suite</em> we are going to create. This automatic test suite will help us during phases such as refactoring, improving code readability and method evolution.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="nd">@Test</span>
</span><span class='line'><span class="kd">public</span> <span class="kt">void</span> <span class="nf">testAcceptObjectNotAcceptedBecauseDifferentType</span><span class="o">()</span> <span class="kd">throws</span> <span class="n">Exception</span> <span class="o">{</span>
</span><span class='line'>    <span class="n">assertFalse</span><span class="o">(</span><span class="n">collector</span><span class="o">.</span><span class="na">accept</span><span class="o">(</span><span class="k">new</span> <span class="nf">Object</span><span class="o">(),</span> <span class="mi">1L</span><span class="o">));</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>Our automatic net of tests starts to take shape.</p>

<h4>Method flush() - 1 error</h4>

<p>The method <code>flush()</code> does not have a return type, so how can we test the <em>correct behavior</em>?</p>

<p><strong>Idea:</strong> indeed, we want to test the correct behavior! we need to find a way to check if the behavior of the method is the expected one so if it follows the right path. When <code>flush()</code> is invoke we expect the creation of a <code>TweetTask</code> object and the invocation of <code>addTask()</code> method.</p>

<p>Let&rsquo;s try step by step. If not done yet by the IDE, create method <code>testFlushGoldenPath()</code> and invoke the method <code>flush()</code>, then <em>run the test!</em></p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="nd">@Test</span>
</span><span class='line'><span class="kd">public</span> <span class="kt">void</span> <span class="nf">testFlushGoldenPath</span><span class="o">()</span> <span class="kd">throws</span> <span class="n">Exception</span> <span class="o">{</span>
</span><span class='line'>    <span class="n">collector</span><span class="o">.</span><span class="na">flush</span><span class="o">(</span><span class="n">USER_ID</span><span class="o">);</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<h5>Error 1</h5>

<p><strong>Issue:</strong> a <code>NullPointerException</code> is thrown. This is not a good behavior, the map has not been initialized if the method will be directly called.</p>

<p><strong>Pre-solution:</strong> check if in the map exist a <code>List</code> for the given <code>userId</code>, if not simply exit from the method execution (other solutions are acceptable, depends on requirements), <em>rerun the method</em>.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="k">if</span> <span class="o">(</span><span class="n">processingList</span><span class="o">.</span><span class="na">get</span><span class="o">(</span><span class="n">userId</span><span class="o">)</span> <span class="o">==</span> <span class="kc">null</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>    <span class="k">return</span><span class="o">;</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>The test passes, but <strong>no verification</strong> is done, so the test is pretty <em>useless</em>. We want to verify that if there is an item, a new <code>TweetTask</code> is created and the method <code>callbackFunction.addTask()</code> is invoked.</p>

<p><strong>Idea:</strong> the <code>callbackFunction</code> has not been set yet so a possible <code>NPE</code> could arise. May be in the future it will be inject by <em>DI</em>. So we can use <a href="https://code.google.com/p/mockito/">Mockito</a> to create a mock object and verify if the method <code>addTask()</code> has been called.</p>

<p><strong>Solution:</strong> mock a <code>Callback.class</code> class in order to make a verification on an <em>expected behavior</em> and change a bit the <code>setUp()</code> method to initialize mocks via annotations. Moreover set the callback and add at least one tweet object just to reproduce a small common scenario.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="nd">@Mock</span>
</span><span class='line'><span class="kd">private</span> <span class="n">Callback</span> <span class="n">callbackFunctionMock</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'><span class="nd">@Before</span>
</span><span class='line'><span class="kd">public</span> <span class="kt">void</span> <span class="nf">setUp</span><span class="o">()</span> <span class="kd">throws</span> <span class="n">Exception</span> <span class="o">{</span>
</span><span class='line'>    <span class="n">MockitoAnnotations</span><span class="o">.</span><span class="na">initMocks</span><span class="o">(</span><span class="k">this</span><span class="o">);</span>
</span><span class='line'>    <span class="n">collector</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">TweetCollector</span><span class="o">();</span>
</span><span class='line'><span class="o">}</span>
</span><span class='line'>
</span><span class='line'><span class="nd">@Test</span>
</span><span class='line'><span class="kd">public</span> <span class="kt">void</span> <span class="nf">testFlushGoldenPath</span><span class="o">()</span> <span class="kd">throws</span> <span class="n">Exception</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">collector</span><span class="o">.</span><span class="na">setCallbackFunction</span><span class="o">(</span><span class="n">callbackFunctionMock</span><span class="o">);</span>
</span><span class='line'>    <span class="n">collector</span><span class="o">.</span><span class="na">accept</span><span class="o">(</span><span class="k">new</span> <span class="nf">Tweet</span><span class="o">(</span><span class="s">&quot;foo tweet&quot;</span><span class="o">),</span> <span class="n">USER_ID</span><span class="o">);</span>
</span><span class='line'>    <span class="n">collector</span><span class="o">.</span><span class="na">flush</span><span class="o">(</span><span class="n">USER_ID</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">verify</span><span class="o">(</span><span class="n">callbackFunctionMock</span><span class="o">,</span> <span class="n">times</span><span class="o">(</span><span class="mi">1</span><span class="o">)).</span><span class="na">addTask</span><span class="o">(</span><span class="n">any</span><span class="o">(</span><span class="n">TweetTask</span><span class="o">.</span><span class="na">class</span><span class="o">),</span> <span class="n">anyInt</span><span class="o">());</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>So we set the callback function, we invoke the <code>accept()</code> method to put one tweet into the list for a given user and finally we call the <code>flush()</code> method. A mock object is useful to verify behaviors for instance if a given method has been called. In our case we want to verify if the method <code>addTask()</code> has been called <em>exactly one time</em>. <code>any(java.lang.Class)</code> and <code>anyInt()</code> belongs to <code>org.mockito.Matchers</code> library. A <em>matcher</em> is an entity that helps to match <em>parameters</em> and <em>arguments</em>. For instance, in the test, we need to mach method call <em>parameters</em>, <code>addTask(java.util.concurrent.Callable task, long userId)</code>, but we are not interested to pass specific <em>arguments</em> so we use <em>matchers</em> to say whatever object implementing <code>Callable</code> class is fine.</p>

<p><strong>Why?</strong> Well, we are not directly call the <code>addTask</code>, we just call a method from a public interface that, under certain condition, should call <code>addTask</code> with a newly created object. We do not control and we do not want to control the creation of the object, just let it be, but we want to verify if the method has been invoked with some instances of a given class. In Mockito if we use a matcher for an argument, all the other arguments must be substituted with matchers.</p>

<p><strong>Best practice</strong> Name a mock variable with <code>mock</code> prefix in order to recognize at first sight which variable is a reference to a real object or to a mock. Other patterns are possible, chose the one you like and keep the whole project consistent.</p>

<p><strong>Attention</strong> A test class is not just a test on methods but it is a <em>test to verify the correct behavior of the all unit</em>.</p>

<h5>Alternative solution with Mockito.spy()</h5>

<p>A <em>mock object</em> has been used, but another kind of test double exists, the <em>spy</em>. A <code>spy</code> is a <em>stub</em> (state verification) able to record <em>calling information</em>, it is a <em>&ldquo;partial mock&rdquo;</em>. Instead of doing the check on <code>processingList.get(userId)</code> at the beginning of the class it is possible to refactor the tweet creation in a separate method as</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="nd">@Override</span>
</span><span class='line'><span class="kd">public</span> <span class="kt">void</span> <span class="nf">flush</span><span class="o">(</span><span class="kt">long</span> <span class="n">userId</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="c1">// create a new processing task</span>
</span><span class='line'>    <span class="k">if</span> <span class="o">(</span><span class="n">callbackFunction</span> <span class="o">!=</span> <span class="kc">null</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>        <span class="n">TweetTask</span> <span class="n">tweetTask</span> <span class="o">=</span> <span class="n">getTweetTask</span><span class="o">(</span><span class="n">userId</span><span class="o">);</span>
</span><span class='line'>        <span class="k">if</span><span class="o">(</span><span class="n">tweetTask</span> <span class="o">!=</span> <span class="kc">null</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>            <span class="n">callbackFunction</span><span class="o">.</span><span class="na">addTask</span><span class="o">(</span><span class="n">tweetTask</span><span class="o">,</span> <span class="n">userId</span><span class="o">);</span>
</span><span class='line'>        <span class="o">}</span>
</span><span class='line'>    <span class="o">}</span> <span class="k">else</span> <span class="o">{</span>
</span><span class='line'>        <span class="k">throw</span> <span class="k">new</span> <span class="nf">IllegalArgumentException</span><span class="o">(</span><span class="s">&quot;Callback function must be set by the service.&quot;</span><span class="o">);</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span><span class='line'>
</span><span class='line'><span class="kd">protected</span> <span class="n">TweetTask</span> <span class="nf">getTweetTask</span><span class="o">(</span><span class="kt">long</span> <span class="n">userId</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>    <span class="n">TweetTask</span> <span class="n">tweetTask</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">TweetTask</span><span class="o">(</span><span class="k">new</span> <span class="n">ArrayList</span><span class="o">&lt;&gt;(</span><span class="n">processingList</span><span class="o">.</span><span class="na">get</span><span class="o">(</span><span class="n">userId</span><span class="o">)));</span>
</span><span class='line'>    <span class="n">processingList</span><span class="o">.</span><span class="na">get</span><span class="o">(</span><span class="n">userId</span><span class="o">).</span><span class="na">clear</span><span class="o">();</span>
</span><span class='line'>    <span class="k">return</span> <span class="n">tweetTask</span><span class="o">;</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>and the corresponding modified test using <code>Mokito.spy()</code> to avoid the invoke on method <code>accept()</code></p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="nd">@Test</span>
</span><span class='line'><span class="kd">public</span> <span class="kt">void</span> <span class="nf">testFlushWithSpyGoldenPath</span><span class="o">()</span> <span class="kd">throws</span> <span class="n">Exception</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">TweetCollector</span> <span class="n">spyOnTweetCollector</span> <span class="o">=</span> <span class="n">Mockito</span><span class="o">.</span><span class="na">spy</span><span class="o">(</span><span class="n">TweetCollector</span><span class="o">.</span><span class="na">class</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">spyOnTweetCollector</span><span class="o">.</span><span class="na">setCallbackFunction</span><span class="o">(</span><span class="n">callbackFunctionMock</span><span class="o">);</span>
</span><span class='line'>    <span class="n">doReturn</span><span class="o">(</span><span class="k">new</span> <span class="nf">TweetTask</span><span class="o">(</span><span class="k">new</span> <span class="n">ArrayList</span><span class="o">&lt;</span><span class="n">Tweet</span><span class="o">&gt;())).</span><span class="na">when</span><span class="o">(</span><span class="n">spyOnTweetCollector</span><span class="o">).</span><span class="na">getTweetTask</span><span class="o">(</span><span class="n">USER_ID</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">spyOnTweetCollector</span><span class="o">.</span><span class="na">flush</span><span class="o">(</span><span class="n">USER_ID</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">verify</span><span class="o">(</span><span class="n">callbackFunctionMock</span><span class="o">,</span> <span class="n">times</span><span class="o">(</span><span class="mi">1</span><span class="o">)).</span><span class="na">addTask</span><span class="o">(</span><span class="n">any</span><span class="o">(</span><span class="n">TweetTask</span><span class="o">.</span><span class="na">class</span><span class="o">),</span> <span class="n">anyInt</span><span class="o">());</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p><strong>Best practice</strong> Name a spy variable with <code>spyOn</code> prefix in order to recognize at first sight which variable is a reference to a real object, to a spy or to a mock.</p>

<p><strong>Attention</strong> We do not have invoked <code>accept()</code> method</p>

<h5>Another alternative solution without Mockito but with @Override</h5>

<p>Just to make a simple comparison, the above test could have been written without <em>Mockito</em> as follows:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="nd">@Test</span>
</span><span class='line'><span class="kd">public</span> <span class="kt">void</span> <span class="nf">testFlushWithOverrideGoldenPath</span><span class="o">()</span> <span class="kd">throws</span> <span class="n">Exception</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">final</span> <span class="n">AtomicBoolean</span> <span class="n">taskAdded</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">AtomicBoolean</span><span class="o">();</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">Callback</span> <span class="n">callbackFunction</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">CallbackImpl</span><span class="o">(){</span>
</span><span class='line'>        <span class="nd">@Override</span>
</span><span class='line'>        <span class="kd">public</span> <span class="kt">void</span> <span class="nf">addTask</span><span class="o">(</span><span class="n">TweetTask</span> <span class="n">tweetTask</span><span class="o">,</span> <span class="kt">long</span> <span class="n">userId</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>            <span class="n">taskAdded</span><span class="o">.</span><span class="na">set</span><span class="o">(</span><span class="kc">true</span><span class="o">);</span>
</span><span class='line'>        <span class="o">}</span>
</span><span class='line'>    <span class="o">};</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">TweetCollector</span> <span class="n">collector</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">TweetCollector</span><span class="o">(){</span>
</span><span class='line'>        <span class="nd">@Override</span>
</span><span class='line'>        <span class="kd">protected</span> <span class="n">TweetTask</span> <span class="nf">getTweetTask</span><span class="o">(</span><span class="kt">long</span> <span class="n">userId</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>            <span class="k">return</span> <span class="k">new</span> <span class="nf">TweetTask</span><span class="o">(</span><span class="k">new</span> <span class="n">ArrayList</span><span class="o">&lt;</span><span class="n">Tweet</span><span class="o">&gt;());</span>
</span><span class='line'>        <span class="o">}</span>
</span><span class='line'>    <span class="o">};</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">collector</span><span class="o">.</span><span class="na">setCallbackFunction</span><span class="o">(</span><span class="n">callbackFunction</span><span class="o">);</span>
</span><span class='line'>    <span class="n">collector</span><span class="o">.</span><span class="na">flush</span><span class="o">(</span><span class="n">USER_ID</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">assertTrue</span><span class="o">(</span><span class="n">taskAdded</span><span class="o">.</span><span class="na">get</span><span class="o">());</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>The use of <em>Mockito</em> makes the code more concise, easy to read, maintain and understand. Moreover the <em>behavior verification</em> is easy to understand than using a variable and check its value. By using &lsquo;verify()&rsquo; we directly verify if the method has been called and how many times, it is <strong>clear</strong> that we are doing <em>behavior verification</em>.</p>

<h5>Additional tests</h5>

<p>Another test can be written to <a href="http://junit.org/apidocs/org/junit/rules/ExpectedException.html">test the exception</a> along with the message in case the <code>callbackFunction</code> is not set.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="nd">@Test</span>
</span><span class='line'><span class="kd">public</span> <span class="kt">void</span> <span class="nf">testFlushExceptionThrownWithNullCallbackFunction</span><span class="o">()</span> <span class="kd">throws</span> <span class="n">Exception</span> <span class="o">{</span>
</span><span class='line'>    <span class="n">exception</span><span class="o">.</span><span class="na">expect</span><span class="o">(</span><span class="n">IllegalArgumentException</span><span class="o">.</span><span class="na">class</span><span class="o">);</span>
</span><span class='line'>    <span class="n">exception</span><span class="o">.</span><span class="na">expectMessage</span><span class="o">(</span><span class="s">&quot;Callback function is null, it must be set by the service.&quot;</span><span class="o">);</span>
</span><span class='line'>    <span class="n">collector</span><span class="o">.</span><span class="na">accept</span><span class="o">(</span><span class="k">new</span> <span class="nf">Tweet</span><span class="o">(</span><span class="s">&quot;foo tweet&quot;</span><span class="o">),</span> <span class="n">USER_ID</span><span class="o">);</span>
</span><span class='line'>    <span class="n">collector</span><span class="o">.</span><span class="na">flush</span><span class="o">(</span><span class="n">USER_ID</span><span class="o">);</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>Exception messages are really important in order to immediately find the root cause of the issue.</p>

<hr />

<h3>CloudService Class</h3>

<p><img class="center" src="http://blackat.github.io/images/posts/cloud-service.png"></p>

<p>Once the service is created, once or more collectors are added in order to provide batch processing to one or more social networks or other services. A user has to open a connection to the service through the method <code>openConnection()</code> and then start to post tweets invoking <code>saveObject()</code>. Once done the user calls method <code>saveObjectCompleted()</code> to post latest tweets and close the connection.</p>

<h4>CloudServiceTest Class</h4>

<p>Create the class as done for the previous example and initialize the <em>System Under Test (SUT)</em>. The test class is the API client exposed by the SUT. The <code>setUp()</code> method properly initializes the SUT in order to be ready for the test method.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">CloudServiceTest</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">private</span> <span class="n">CloudService</span> <span class="n">cloudService</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">private</span> <span class="n">Callback</span> <span class="n">callbackFunction</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>    <span class="nd">@Before</span>
</span><span class='line'>    <span class="kd">public</span> <span class="kt">void</span> <span class="nf">setUp</span><span class="o">()</span> <span class="kd">throws</span> <span class="n">Exception</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>        <span class="n">callbackFunction</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">CallbackImpl</span><span class="o">();</span>
</span><span class='line'>        <span class="n">cloudService</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">CloudService</span><span class="o">(</span><span class="n">callbackFunction</span><span class="o">);</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<h4>Method addCollector() - 2 errors</h4>

<p>Create the first test for method <code>addCollector()</code></p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="nd">@Test</span>
</span><span class='line'><span class="kd">public</span> <span class="kt">void</span> <span class="nf">testAddCollectorGoldenPath</span><span class="o">()</span> <span class="kd">throws</span> <span class="n">Exception</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">cloudService</span><span class="o">.</span><span class="na">addCollector</span><span class="o">(</span><span class="k">new</span> <span class="nf">TweetCollector</span><span class="o">());</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">assertEquals</span><span class="o">(</span><span class="mi">1</span><span class="o">,</span> <span class="n">cloudService</span><span class="o">.</span><span class="na">getCollectorSize</span><span class="o">());</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<h5>Error 1</h5>

<p><strong>Issue:</strong> a <code>NullPointerException</code> will be thrown when <code>CloudService.getCollectorSize()</code> is called in the assertion.</p>

<p><strong>Solution:</strong> the object <code>processingCollectors</code> has not been initialized. Add the initialization in the constructor, for instance, and <em>rerun the test</em>.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="nf">CloudService</span><span class="o">(</span><span class="n">Callback</span> <span class="n">callback</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">processingCollectors</span> <span class="o">=</span> <span class="k">new</span> <span class="n">HashMap</span><span class="o">&lt;&gt;();</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<h5>Error 2 - Test Driven Development (TDD)</h5>

<p>Spot this error is not easy, it is a missing code. As it has been seen before, a collector uses a callback function to post a batch processing. When a collector is added the callback function must be set by the service. The collector in this situation acts as a <em>collaborator</em> and we want to verify that a specific method is invoke on the collaborator itself. Create the <em>test before</em> and <em>implementation later on</em> to make the test passes (TDD).</p>

<p>In order to verify a method call, i.e. <em>indirect output</em>, we use Mockito, so add <code>tweetCollectorMock</code> variable and init mocks inside of the <code>setUp()</code> (initialization of the test fixture) method adding <code>MockitoAnnotations.initMocks(this)</code> and <em>run the test</em></p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="nd">@Mock</span>
</span><span class='line'><span class="kd">private</span> <span class="n">TweetCollector</span> <span class="n">tweetCollectorMock</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'><span class="nd">@Before</span>
</span><span class='line'><span class="kd">public</span> <span class="kt">void</span> <span class="nf">setUp</span><span class="o">()</span> <span class="kd">throws</span> <span class="n">Exception</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">MockitoAnnotations</span><span class="o">.</span><span class="na">initMocks</span><span class="o">(</span><span class="k">this</span><span class="o">);</span>
</span><span class='line'>    <span class="n">callbackFunction</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">CallbackImpl</span><span class="o">();</span>
</span><span class='line'>    <span class="n">cloudService</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">CloudService</span><span class="o">(</span><span class="n">callbackFunction</span><span class="o">);</span>
</span><span class='line'><span class="o">}</span>
</span><span class='line'>
</span><span class='line'><span class="nd">@Test</span>
</span><span class='line'><span class="kd">public</span> <span class="kt">void</span> <span class="nf">testAddCollectorVerifyCallbackFunctionAddedWithMockito</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">cloudService</span><span class="o">.</span><span class="na">addCollector</span><span class="o">(</span><span class="n">tweetCollectorMock</span><span class="o">);</span>
</span><span class='line'>    <span class="n">verify</span><span class="o">(</span><span class="n">tweetCollectorMock</span><span class="o">,</span> <span class="n">times</span><span class="o">(</span><span class="mi">1</span><span class="o">)).</span><span class="na">setCallbackFunction</span><span class="o">(</span><span class="n">any</span><span class="o">(</span><span class="n">Callback</span><span class="o">.</span><span class="na">class</span><span class="o">));</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p><strong>Issue:</strong> an error is thrown <code>Wanted but not invoked:...</code> that means the method <code>setCallbackFunction()</code> has not been called.</p>

<p><strong>Solution:</strong> in the method <code>addCollector()</code> add the call to set the callback function and  <em>rerun the test</em>.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="nd">@Override</span>
</span><span class='line'><span class="kd">public</span> <span class="kt">void</span> <span class="nf">addCollector</span><span class="o">(</span><span class="n">Collector</span> <span class="n">collector</span><span class="o">)</span> <span class="kd">throws</span> <span class="n">RuntimeException</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">processingCollectors</span><span class="o">.</span><span class="na">add</span><span class="o">(</span><span class="n">collector</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">collector</span><span class="o">.</span><span class="na">setCallbackFunction</span><span class="o">(</span><span class="n">callbackFunction</span><span class="o">);</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>Now the test passes. The <code>addCollector()</code> function has been corrected by tests. The tests have been left separated for two reasons:</p>

<ol>
<li>test two different aspects of the same function</li>
<li>how <em>Test Driven Development (TDD)</em> helps building a solid net of automated tests and a more reliable code, tests come directly from requirements.</li>
</ol>


<p><strong>Attention!</strong> TDD helps creating a tests net, tests represent the requirements, the documentation as code that can be read to understand the behavior of the class. The code satisfying the tests is consistent with the requirements, its behavior is something to <em>rely on</em> for the next development iteration.</p>

<h5>Error 2 - Alternative solution with @Override</h5>

<p>Instead of using a mocking framework, it is possible to <em>&ldquo;intercept&rdquo;</em> the call of the method and register a status that can be used for verification later on as following:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="nd">@Test</span>
</span><span class='line'><span class="kd">public</span> <span class="kt">void</span> <span class="nf">testAddCollectorVerifyCallbackFunctionAddedWithOverride</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">final</span> <span class="n">AtomicInteger</span> <span class="n">functionCalled</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">AtomicInteger</span><span class="o">();</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">cloudService</span><span class="o">.</span><span class="na">addCollector</span><span class="o">(</span><span class="k">new</span> <span class="nf">TweetCollector</span><span class="o">(){</span>
</span><span class='line'>
</span><span class='line'>    <span class="nd">@Override</span>
</span><span class='line'>    <span class="kd">public</span> <span class="kt">void</span> <span class="nf">setCallbackFunction</span><span class="o">(</span><span class="n">Callback</span> <span class="n">callback</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>            <span class="n">functionCalled</span><span class="o">.</span><span class="na">set</span><span class="o">(</span><span class="mi">1</span><span class="o">);</span>
</span><span class='line'>        <span class="o">}</span>
</span><span class='line'>    <span class="o">});</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">assertEquals</span><span class="o">(</span><span class="mi">1</span><span class="o">,</span> <span class="n">functionCalled</span><span class="o">.</span><span class="na">get</span><span class="o">());</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>The use of a mock object and a mocking framework as Mockito allows to have a more concise and readable code. Methods and matchers such as  <code>verify</code>, <code>times()</code> and <code>any()</code> make the comprehension of the test easier. Moreover using a mock for a collector makes clearer that in this context it a <em>collaborator</em> and not the object of the test, it is even closer to a documentation purpose.</p>

<h4>Method openConnection() - 1 error</h4>

<p>Let&rsquo;s create a new test and run it</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="nd">@Test</span>
</span><span class='line'><span class="kd">public</span> <span class="kt">void</span> <span class="nf">testOpenConnectionGoldenPath</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>    <span class="n">cloudService</span><span class="o">.</span><span class="na">openConnection</span><span class="o">(</span><span class="n">USER_ID</span><span class="o">);</span>
</span><span class='line'>    <span class="n">assertTrue</span><span class="o">(</span><span class="n">cloudService</span><span class="o">.</span><span class="na">isUserConnected</span><span class="o">(</span><span class="n">USER_ID</span><span class="o">));</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<h5>Error 1</h5>

<p><strong>Issue:</strong> a <code>NullPointerException</code> will be thrown.</p>

<p><strong>Solution:</strong> the object <code>processingFutureList</code> has not been initialized. Add the initialization in the constructor for instance and <em>rerun the test</em>.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="nf">CloudService</span><span class="o">(</span><span class="n">Callback</span> <span class="n">callback</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">processingFutureList</span> <span class="o">=</span> <span class="k">new</span> <span class="n">HashMap</span><span class="o">&lt;&gt;();</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">processingCollectors</span> <span class="o">=</span> <span class="k">new</span> <span class="n">ArrayList</span><span class="o">&lt;&gt;();</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>Now the test passes.</p>

<h5>Additional test</h5>

<p>To build a <em>net of automatic tests</em> is interesting to test different aspects of a method so we can add the following one</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="nd">@Test</span>
</span><span class='line'><span class="kd">public</span> <span class="kt">void</span> <span class="nf">testOpenConnectionUserHasNotOpenConnection</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>    <span class="n">assertFalse</span><span class="o">(</span><span class="n">cloudService</span><span class="o">.</span><span class="na">isUserConnected</span><span class="o">(</span><span class="n">USER_ID</span><span class="o">));</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<h4>Method saveObject() - 0 errors</h4>

<p>This method does not have errors anymore, but one or more test must be written to build up an efficient <em>test suite</em>. It is a small workflow able to test the interface exposed by the class.</p>

<p><strong>Remember!</strong> Test the behavior of <em>all the unit</em> not just single and separated methods, the focus is on the all unit.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
<span class='line-number'>26</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="nd">@Test</span>
</span><span class='line'><span class="kd">public</span> <span class="kt">void</span> <span class="nf">testSaveObjectWithOverrideGoldenPath</span><span class="o">()</span> <span class="kd">throws</span> <span class="n">Exception</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">final</span> <span class="n">AtomicBoolean</span> <span class="n">accepted</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">AtomicBoolean</span><span class="o">();</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">Collector</span> <span class="n">tweetCollector</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">TweetCollector</span><span class="o">(){</span>
</span><span class='line'>        <span class="nd">@Override</span>
</span><span class='line'>        <span class="kd">public</span> <span class="kt">boolean</span> <span class="nf">accept</span><span class="o">(</span><span class="n">Object</span> <span class="n">object</span><span class="o">,</span> <span class="kt">long</span> <span class="n">userId</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>            <span class="k">if</span> <span class="o">(</span><span class="n">object</span> <span class="k">instanceof</span> <span class="n">Tweet</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>                <span class="n">accepted</span><span class="o">.</span><span class="na">set</span><span class="o">(</span><span class="kc">true</span><span class="o">);</span>
</span><span class='line'>                <span class="k">return</span> <span class="kc">true</span><span class="o">;</span>
</span><span class='line'>            <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>            <span class="k">return</span> <span class="kc">false</span><span class="o">;</span>
</span><span class='line'>        <span class="o">}</span>
</span><span class='line'>    <span class="o">};</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">cloudService</span><span class="o">.</span><span class="na">addCollector</span><span class="o">(</span><span class="n">tweetCollector</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">cloudService</span><span class="o">.</span><span class="na">openConnection</span><span class="o">(</span><span class="n">USER_ID</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">cloudService</span><span class="o">.</span><span class="na">saveObject</span><span class="o">(</span><span class="k">new</span> <span class="nf">Tweet</span><span class="o">(</span><span class="s">&quot;foo tweet&quot;</span><span class="o">),</span> <span class="n">USER_ID</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">assertTrue</span><span class="o">(</span><span class="n">accepted</span><span class="o">.</span><span class="na">get</span><span class="o">());</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>Once again pay attention on the difference between using <em>override</em> and <em>Mockito</em> to test <em>indirect output</em> as follows</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="nd">@Test</span>
</span><span class='line'><span class="kd">public</span> <span class="kt">void</span> <span class="nf">testSaveObjectWithMockitoGoldenPath</span><span class="o">()</span> <span class="kd">throws</span> <span class="n">Exception</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">Collector</span> <span class="n">collectorMock</span> <span class="o">=</span> <span class="n">mock</span><span class="o">(</span><span class="n">TweetCollector</span><span class="o">.</span><span class="na">class</span><span class="o">);</span>
</span><span class='line'>    <span class="n">when</span><span class="o">(</span><span class="n">collectorMock</span><span class="o">.</span><span class="na">accept</span><span class="o">(</span><span class="n">any</span><span class="o">(</span><span class="n">Tweet</span><span class="o">.</span><span class="na">class</span><span class="o">),</span> <span class="n">anyInt</span><span class="o">())).</span><span class="na">thenReturn</span><span class="o">(</span><span class="kc">true</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">cloudService</span><span class="o">.</span><span class="na">addCollector</span><span class="o">(</span><span class="n">collectorMock</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">cloudService</span><span class="o">.</span><span class="na">openConnection</span><span class="o">(</span><span class="n">USER_ID</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">cloudService</span><span class="o">.</span><span class="na">saveObject</span><span class="o">(</span><span class="n">tweetMock</span><span class="o">,</span> <span class="n">USER_ID</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">verify</span><span class="o">(</span><span class="n">collectorMock</span><span class="o">,</span> <span class="n">times</span><span class="o">(</span><span class="mi">1</span><span class="o">)).</span><span class="na">accept</span><span class="o">(</span><span class="n">any</span><span class="o">(</span><span class="n">Tweet</span><span class="o">.</span><span class="na">class</span><span class="o">),</span> <span class="n">anyInt</span><span class="o">());</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>Once again the use of Mockito allows to have a more concise and readable test. The <code>Mockito.verify()</code> method highlights the test of the <em>indirect output</em>.</p>

<h4>Additional class behavior tests</h4>

<h5>Additional test 1</h5>

<p>It is interesting to enrich the test suite with some other tests, may be a bit redundant but useful to highlight if the code correctly answer to borderline scenarios.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="nd">@Rule</span>
</span><span class='line'><span class="kd">public</span> <span class="n">ExpectedException</span> <span class="n">exception</span> <span class="o">=</span> <span class="n">ExpectedException</span><span class="o">.</span><span class="na">none</span><span class="o">();</span>
</span><span class='line'>
</span><span class='line'><span class="nd">@Test</span>
</span><span class='line'><span class="kd">public</span> <span class="kt">void</span> <span class="nf">testSaveObjectObjectNotAcceptedThrowException</span><span class="o">()</span> <span class="kd">throws</span> <span class="n">Exception</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">exception</span><span class="o">.</span><span class="na">expect</span><span class="o">(</span><span class="n">IllegalArgumentException</span><span class="o">.</span><span class="na">class</span><span class="o">);</span>
</span><span class='line'>    <span class="n">exception</span><span class="o">.</span><span class="na">expectMessage</span><span class="o">(</span><span class="s">&quot;Entity of type &quot;</span> <span class="o">+</span> <span class="k">new</span> <span class="nf">Object</span><span class="o">().</span><span class="na">getClass</span><span class="o">()</span> <span class="o">+</span> <span class="s">&quot; cannot be accepted.&quot;</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">cloudService</span><span class="o">.</span><span class="na">addCollector</span><span class="o">(</span><span class="k">new</span> <span class="nf">TweetCollector</span><span class="o">());</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">cloudService</span><span class="o">.</span><span class="na">openConnection</span><span class="o">(</span><span class="n">USER_ID</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">cloudService</span><span class="o">.</span><span class="na">saveObject</span><span class="o">(</span><span class="k">new</span> <span class="nf">Object</span><span class="o">(),</span> <span class="n">USER_ID</span><span class="o">);</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<h5>Additional test 2</h5>

<p>The name of the method makes the test self-explanatory.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="nd">@Test</span>
</span><span class='line'><span class="kd">public</span> <span class="kt">void</span> <span class="nf">testSaveObjectUserNotConnected</span><span class="o">()</span> <span class="kd">throws</span> <span class="n">Exception</span> <span class="o">{</span>
</span><span class='line'>    <span class="n">exception</span><span class="o">.</span><span class="na">expect</span><span class="o">(</span><span class="n">IllegalArgumentException</span><span class="o">.</span><span class="na">class</span><span class="o">);</span>
</span><span class='line'>    <span class="n">exception</span><span class="o">.</span><span class="na">expectMessage</span><span class="o">(</span><span class="s">&quot;User with id &quot;</span> <span class="o">+</span> <span class="n">USER_ID</span> <span class="o">+</span> <span class="s">&quot; has not open any connection, please open a connection &quot;</span> <span class="o">+</span>
</span><span class='line'>        <span class="s">&quot;before trying to save.&quot;</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">cloudService</span><span class="o">.</span><span class="na">saveObject</span><span class="o">(</span><span class="n">mock</span><span class="o">(</span><span class="n">Callable</span><span class="o">.</span><span class="na">class</span><span class="o">),</span> <span class="n">USER_ID</span><span class="o">);</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<h5>Additional test 3</h5>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="nd">@Test</span>
</span><span class='line'><span class="kd">public</span> <span class="kt">void</span> <span class="nf">testSaveObjectCompletedUserNotConnectedThrowException</span><span class="o">()</span> <span class="kd">throws</span> <span class="n">Exception</span> <span class="o">{</span>
</span><span class='line'>    <span class="n">exception</span><span class="o">.</span><span class="na">expect</span><span class="o">(</span><span class="n">IllegalArgumentException</span><span class="o">.</span><span class="na">class</span><span class="o">);</span>
</span><span class='line'>    <span class="n">exception</span><span class="o">.</span><span class="na">expectMessage</span><span class="o">(</span><span class="s">&quot;User with id &quot;</span> <span class="o">+</span> <span class="n">USER_ID</span> <span class="o">+</span> <span class="s">&quot; has not open any connection, please open a connection &quot;</span> <span class="o">+</span>
</span><span class='line'>        <span class="s">&quot;before trying to save.&quot;</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">cloudService</span><span class="o">.</span><span class="na">saveObjectCompleted</span><span class="o">(</span><span class="kc">null</span><span class="o">,</span> <span class="n">USER_ID</span><span class="o">);</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<h5>Additional test 4</h5>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="nd">@Test</span>
</span><span class='line'><span class="kd">public</span> <span class="kt">void</span> <span class="nf">testSaveObjectCompletedGoldenPath</span><span class="o">()</span> <span class="kd">throws</span> <span class="n">Exception</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">doNothing</span><span class="o">().</span><span class="na">when</span><span class="o">(</span><span class="n">acknoledgeServiceMock</span><span class="o">).</span><span class="na">sendAckSuccess</span><span class="o">();</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">TweetCollector</span> <span class="n">spyOntweetCollector</span> <span class="o">=</span> <span class="n">spy</span><span class="o">(</span><span class="k">new</span> <span class="nf">TweetCollector</span><span class="o">());</span>
</span><span class='line'>    <span class="c1">// if you call the real method there will be an exception, use doReturn for stubbing</span>
</span><span class='line'>    <span class="n">doReturn</span><span class="o">(</span><span class="n">tweetTaskMock</span><span class="o">).</span><span class="na">when</span><span class="o">(</span><span class="n">spyOntweetCollector</span><span class="o">).</span><span class="na">getTweetTask</span><span class="o">(</span><span class="n">USER_ID</span><span class="o">);</span>
</span><span class='line'>    <span class="n">when</span><span class="o">(</span><span class="n">tweetTaskMock</span><span class="o">.</span><span class="na">call</span><span class="o">()).</span><span class="na">thenReturn</span><span class="o">(</span><span class="mi">1L</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">cloudService</span><span class="o">.</span><span class="na">addCollector</span><span class="o">(</span><span class="n">spyOntweetCollector</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">cloudService</span><span class="o">.</span><span class="na">openConnection</span><span class="o">(</span><span class="n">USER_ID</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">cloudService</span><span class="o">.</span><span class="na">saveObject</span><span class="o">(</span><span class="k">new</span> <span class="nf">Tweet</span><span class="o">(</span><span class="s">&quot;foo tweet&quot;</span><span class="o">),</span> <span class="n">USER_ID</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">cloudService</span><span class="o">.</span><span class="na">saveObjectCompleted</span><span class="o">(</span><span class="n">acknoledgeServiceMock</span><span class="o">,</span> <span class="n">USER_ID</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">verify</span><span class="o">(</span><span class="n">tweetTaskMock</span><span class="o">,</span> <span class="n">times</span><span class="o">(</span><span class="mi">1</span><span class="o">)).</span><span class="na">call</span><span class="o">();</span>
</span><span class='line'>    <span class="n">verify</span><span class="o">(</span><span class="n">acknoledgeServiceMock</span><span class="o">,</span> <span class="n">times</span><span class="o">(</span><span class="mi">1</span><span class="o">)).</span><span class="na">sendAckSuccess</span><span class="o">();</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<h5>Additional test 5</h5>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="nd">@Test</span>
</span><span class='line'><span class="kd">public</span> <span class="kt">void</span> <span class="nf">testSaveObjectCompletedExceptionThrown</span><span class="o">()</span> <span class="kd">throws</span> <span class="n">Exception</span> <span class="o">{</span>
</span><span class='line'>    <span class="n">doNothing</span><span class="o">().</span><span class="na">when</span><span class="o">(</span><span class="n">acknoledgeServiceMock</span><span class="o">).</span><span class="na">sendAckSuccess</span><span class="o">();</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">TweetCollector</span> <span class="n">spyOntweetCollector</span> <span class="o">=</span> <span class="n">spy</span><span class="o">(</span><span class="k">new</span> <span class="nf">TweetCollector</span><span class="o">());</span>
</span><span class='line'>    <span class="c1">// if you call the real method there will be an exception, use doReturn for stubbing</span>
</span><span class='line'>    <span class="n">doReturn</span><span class="o">(</span><span class="n">tweetTaskMock</span><span class="o">).</span><span class="na">when</span><span class="o">(</span><span class="n">spyOntweetCollector</span><span class="o">).</span><span class="na">getTweetTask</span><span class="o">(</span><span class="n">USER_ID</span><span class="o">);</span>
</span><span class='line'>    <span class="n">when</span><span class="o">(</span><span class="n">tweetTaskMock</span><span class="o">.</span><span class="na">call</span><span class="o">()).</span><span class="na">thenThrow</span><span class="o">(</span><span class="n">InterruptedException</span><span class="o">.</span><span class="na">class</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">cloudService</span><span class="o">.</span><span class="na">addCollector</span><span class="o">(</span><span class="n">spyOntweetCollector</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">cloudService</span><span class="o">.</span><span class="na">openConnection</span><span class="o">(</span><span class="n">USER_ID</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">cloudService</span><span class="o">.</span><span class="na">saveObject</span><span class="o">(</span><span class="k">new</span> <span class="nf">Tweet</span><span class="o">(</span><span class="s">&quot;foo tweet&quot;</span><span class="o">),</span> <span class="n">USER_ID</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">cloudService</span><span class="o">.</span><span class="na">saveObjectCompleted</span><span class="o">(</span><span class="n">acknoledgeServiceMock</span><span class="o">,</span> <span class="n">USER_ID</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="n">verify</span><span class="o">(</span><span class="n">tweetTaskMock</span><span class="o">,</span> <span class="n">times</span><span class="o">(</span><span class="mi">1</span><span class="o">)).</span><span class="na">call</span><span class="o">();</span>
</span><span class='line'>    <span class="n">verify</span><span class="o">(</span><span class="n">acknoledgeServiceMock</span><span class="o">,</span> <span class="n">times</span><span class="o">(</span><span class="mi">1</span><span class="o">)).</span><span class="na">sendAckFailed</span><span class="o">(</span><span class="n">any</span><span class="o">(</span><span class="n">RuntimeException</span><span class="o">.</span><span class="na">class</span><span class="o">));</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>

]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[JavaScript: Anatomy of an Object]]></title>
    <link href="http://blackat.github.io/blog/2015/02/01/javascript-anatomy-of-an-object/"/>
    <updated>2015-02-01T11:27:38+01:00</updated>
    <id>http://blackat.github.io/blog/2015/02/01/javascript-anatomy-of-an-object</id>
    <content type="html"><![CDATA[<p><strong>JavaScript</strong> is a <em>prototypal inheritance language</em> where objects inherit properties directly from other objects. Differently a <em>class-based languages</em> such as Java defines an object as instance of a class and inheritance hierarchy is defined through classes. Packages then define the layout of files and folders in a project.</p>

<p>Objects in JavaScript are <em>class-free</em> and <em>dynamic</em> or <em>mutable</em>, they can change at any time during code execution. In Java objects are not dynamic, their layout is lock down by class definition.</p>

<p>JavaScript defines a <em>prototype linkage feature</em> to allow an object to inherit properties from another object.</p>

<!-- more -->


<h2>1. Object representation</h2>

<p>The JavaScript world is divided in two big chunks:</p>

<ol>
<li><em>simple types:</em> strings, booleans, numbers, <code>null</code> and <code>undefined</code>;</li>
<li><em>objects:</em> rest of the world such as functions, arrays, regular expressions and, naturally, objects.</li>
</ol>


<blockquote><p>Objects in JavaScripts are mutable keyed collections.</p><footer><strong>Douglas Crockford</strong> <cite><a href='http://shop.oreilly.com/product/9780596517748.do'>JavaScript: The Good Parts</a></cite></footer></blockquote>


<p>An object is represented as a collection of properties where each property has a <em>name</em> and a <em>value</em> as shown in the example below:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
</pre></td><td class='code'><pre><code class='javascript'><span class='line'><span class="s1">&#39;use strict&#39;</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'><span class="kd">var</span> <span class="nx">catFelix</span> <span class="o">=</span> <span class="p">{</span>
</span><span class='line'>    <span class="nx">name</span><span class="o">:</span> <span class="s1">&#39;felix&#39;</span><span class="p">,</span>
</span><span class='line'>    <span class="nx">house</span><span class="o">:</span> <span class="s1">&#39;house&#39;</span><span class="p">,</span>
</span><span class='line'>    <span class="nx">domain</span><span class="o">:</span> <span class="s1">&#39;cat&#39;</span>
</span><span class='line'><span class="p">}</span>
</span><span class='line'>
</span><span class='line'><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">catFelix</span><span class="p">.</span><span class="nx">name</span> <span class="o">+</span> <span class="s1">&#39;@&#39;</span> <span class="o">+</span> <span class="nx">catFelix</span><span class="p">.</span><span class="nx">house</span> <span class="o">+</span> <span class="s1">&#39;.&#39;</span> <span class="o">+</span> <span class="nx">catFelix</span><span class="p">.</span><span class="nx">domain</span><span class="p">);</span>
</span><span class='line'><span class="c1">//output: felix@house.cat</span>
</span></code></pre></td></tr></table></div></figure>


<h2>2. How to create an object</h2>

<h3>2.1 Object literal</h3>

<p>The <em>object literal notation</em> is the easiest way to create an object. It is just a pair of curly brackets:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
</pre></td><td class='code'><pre><code class='javascript'><span class='line'><span class="s1">&#39;use strict&#39;</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'><span class="kd">var</span> <span class="nx">cat</span> <span class="o">=</span> <span class="p">{};</span>
</span></code></pre></td></tr></table></div></figure>


<p>The statement just creates an empty object, optionally it can be then populated as following:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
</pre></td><td class='code'><pre><code class='javascript'><span class='line'><span class="s1">&#39;use strict&#39;</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'><span class="kd">var</span> <span class="nx">cat</span> <span class="o">=</span> <span class="p">{};</span>
</span><span class='line'><span class="nx">cat</span><span class="p">.</span><span class="nx">name</span> <span class="o">=</span> <span class="s1">&#39;just a cat&#39;</span><span class="p">;</span>
</span><span class='line'><span class="nx">cat</span><span class="p">.</span><span class="nx">house</span> <span class="o">=</span> <span class="s1">&#39;none&#39;</span><span class="p">;</span>
</span></code></pre></td></tr></table></div></figure>


<p>Another way is to directly populate the object optionally enclosing a collection of <em>key/value</em> pairs between curly brackets:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
</pre></td><td class='code'><pre><code class='javascript'><span class='line'><span class="s1">&#39;use strict&#39;</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'><span class="kd">var</span> <span class="nx">catFelix</span> <span class="o">=</span> <span class="p">{</span>
</span><span class='line'>    <span class="nx">name</span><span class="o">:</span> <span class="s1">&#39;felix&#39;</span><span class="p">,</span>
</span><span class='line'>    <span class="nx">house</span><span class="o">:</span> <span class="s1">&#39;house&#39;</span><span class="p">,</span>
</span><span class='line'>    <span class="nx">domain</span><span class="o">:</span> <span class="s1">&#39;cat&#39;</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>Whenever is required a new property/value pair can be added to the object. Moreover an object might contain one or more objects as following:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
</pre></td><td class='code'><pre><code class='javascript'><span class='line'><span class="s1">&#39;use strict&#39;</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'><span class="kd">var</span> <span class="nx">catFelix</span> <span class="o">=</span> <span class="p">{</span>
</span><span class='line'>    <span class="nx">name</span><span class="o">:</span> <span class="s1">&#39;felix&#39;</span><span class="p">,</span>
</span><span class='line'>    <span class="nx">house</span><span class="o">:</span> <span class="s1">&#39;house&#39;</span><span class="p">,</span>
</span><span class='line'>    <span class="nx">domain</span><span class="o">:</span> <span class="s1">&#39;cat&#39;</span><span class="p">,</span>
</span><span class='line'>    <span class="nx">features</span><span class="o">:</span> <span class="p">{</span>
</span><span class='line'>        <span class="nx">language</span><span class="o">:</span> <span class="s1">&#39;meow&#39;</span><span class="p">,</span>
</span><span class='line'>        <span class="nx">body</span><span class="o">:</span> <span class="s1">&#39;black&#39;</span><span class="p">,</span>
</span><span class='line'>        <span class="nx">eyes</span><span class="o">:</span> <span class="s1">&#39;white&#39;</span><span class="p">,</span>
</span><span class='line'>        <span class="nx">grin</span><span class="o">:</span> <span class="s1">&#39;giant&#39;</span><span class="p">,</span>
</span><span class='line'>        <span class="nx">photo</span><span class="o">:</span> <span class="s1">&#39;felix-awesome.png&#39;</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>




<blockquote><p>Objects are passed by reference, they are never copied.</p><footer><strong>Douglas Crockford</strong> <cite><a href='http://shop.oreilly.com/product/9780596517748.do'>JavaScript: The Good Parts</a></cite></footer></blockquote>


<h4>2.1.1 Property access</h4>

<p>Once an object has been created, there are two ways to get access to <em>property values</em>, <em>[property_name]</em> and <em>dot notation</em></p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
</pre></td><td class='code'><pre><code class='javascript'><span class='line'><span class="c1">//Object declaration.</span>
</span><span class='line'>
</span><span class='line'><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="s1">&#39;I am &#39;</span> <span class="o">+</span> <span class="nx">catFelix</span><span class="p">[</span><span class="s1">&#39;name&#39;</span><span class="p">]);</span> <span class="c1">// I am felix</span>
</span><span class='line'>
</span><span class='line'><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="s1">&#39;I speak &#39;</span> <span class="o">+</span> <span class="nx">catFelix</span><span class="p">[</span><span class="s1">&#39;features&#39;</span><span class="p">][</span><span class="s1">&#39;language&#39;</span><span class="p">]);</span> <span class="c1">// I speak meow</span>
</span><span class='line'>
</span><span class='line'><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="s1">&#39;I have a &#39;</span> <span class="o">+</span> <span class="nx">catFelix</span><span class="p">.</span><span class="nx">features</span><span class="p">.</span><span class="nx">grin</span> <span class="o">+</span> <span class="s1">&#39; grin&#39;</span><span class="p">);</span> <span class="c1">// I have a giant grin</span>
</span><span class='line'>
</span><span class='line'><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="s1">&#39;My shortcoming is &#39;</span> <span class="o">+</span> <span class="nx">catFelix</span><span class="p">.</span><span class="nx">features</span><span class="p">.</span><span class="nx">shortcoming</span> <span class="o">||</span> <span class="s2">&quot;none&quot;</span><span class="p">);</span> <span class="c1">// My shortcoming is undefined</span>
</span></code></pre></td></tr></table></div></figure>


<h3><a name="function_constructor"></a>2.2 Function Constructor</h3>

<p>A class based language such as Java uses classes to obtain encapsulation and to structure a hierarchy. The constructor will build the object hierarchy and bring an object to an initial and well known state.</p>

<p>A constructor avoid to initialize properties one by one everytime a new object has to be created. JavaScript offers a such mechanism through the <code>new</code> operator.</p>

<blockquote><p>A Constructor is simply a function that is used with `new` to create an object.</p><footer><strong>Douglas Crockford</strong> <cite><a href='http://shop.oreilly.com/product/9780596517748.do'>The Principles of Object-Oriented JavaScript</a></cite></footer></blockquote>




<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
</pre></td><td class='code'><pre><code class='javascript'><span class='line'><span class="s1">&#39;use strict&#39;</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'><span class="kd">function</span> <span class="nx">Cat</span><span class="p">()</span> <span class="p">{};</span>
</span><span class='line'>
</span><span class='line'><span class="kd">var</span> <span class="nx">cat</span> <span class="o">=</span> <span class="nx">Cat</span><span class="p">();</span>
</span><span class='line'><span class="nx">console</span><span class="p">.</span><span class="nx">assert</span><span class="p">(</span><span class="nx">cat</span> <span class="o">===</span> <span class="kc">undefined</span><span class="p">,</span> <span class="s2">&quot;cat is not an object&quot;</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'><span class="kd">var</span> <span class="nx">cat</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">Cat</span><span class="p">();</span>
</span><span class='line'><span class="nx">console</span><span class="p">.</span><span class="nx">assert</span><span class="p">(</span><span class="nx">cat</span> <span class="o">===</span> <span class="kc">undefined</span><span class="p">,</span> <span class="s2">&quot;cat is not anymore undefined&quot;</span><span class="p">);</span>
</span></code></pre></td></tr></table></div></figure>


<p>The function <code>Cat()</code> is defined and it is called in two different ways:</p>

<ol>
<li>not produce any new object and the <code>console.assert</code> method passes;</li>
<li>generate an exception, the <code>new</code> operator has allocated a new object and has automatically returned the reference to it stored in the variable <code>cat</code>.</li>
</ol>


<p>To share properties (methods and variables) among objects of a <em>given type</em> put them on the <em>prototype</em> as follows:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
</pre></td><td class='code'><pre><code class='javascript'><span class='line'><span class="s1">&#39;use strict&#39;</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'><span class="kd">function</span> <span class="nx">Cat</span><span class="p">()</span> <span class="p">{};</span>
</span><span class='line'>
</span><span class='line'><span class="nx">Cat</span><span class="p">.</span><span class="nx">prototype</span><span class="p">.</span><span class="nx">language</span> <span class="o">=</span> <span class="s1">&#39;meow&#39;</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'><span class="nx">Cat</span><span class="p">.</span><span class="nx">prototype</span><span class="p">.</span><span class="nx">legs</span> <span class="o">=</span> <span class="mi">4</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'><span class="nx">Cat</span><span class="p">.</span><span class="nx">prototype</span><span class="p">.</span><span class="nx">getLegs</span> <span class="o">=</span> <span class="kd">function</span><span class="p">()</span> <span class="p">{</span>
</span><span class='line'>    <span class="k">return</span> <span class="k">this</span><span class="p">.</span><span class="nx">legs</span><span class="p">;</span>
</span><span class='line'><span class="p">}</span>
</span><span class='line'>
</span><span class='line'><span class="kd">var</span> <span class="nx">felix</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">Cat</span><span class="p">();</span>
</span><span class='line'><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="s2">&quot;I speak &quot;</span> <span class="o">+</span> <span class="nx">felix</span><span class="p">.</span><span class="nx">language</span> <span class="o">+</span> <span class="s2">&quot; language and I have &quot;</span> <span class="o">+</span> <span class="nx">felix</span><span class="p">.</span><span class="nx">getLegs</span><span class="p">()</span> <span class="o">+</span> <span class="s2">&quot; legs&quot;</span><span class="p">);</span>
</span></code></pre></td></tr></table></div></figure>


<p>Three properties have been attached to <code>prototype</code> having values of type <code>String</code>, <code>int</code> and <code>function</code> respectively. Notice that properties has been <em>attached</em> and not <em>added</em> [<a href="http://www.manning.com/resig/" title="Secrets of the JavaScript Ninja">2</a>]. For this reason JavaScript has been defined as <em>prototypal inheritance language</em>, objects can inherit properties directly from other objects.</p>

<p>Constructors, by convention, are stored in variable with a capitalized name to avoid the risk to be called without <code>new</code> operator.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
</pre></td><td class='code'><pre><code class='javascript'><span class='line'><span class="s1">&#39;use strict&#39;</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'><span class="c1">// Capitalized function name.</span>
</span><span class='line'><span class="kd">function</span> <span class="nx">Cat</span><span class="p">()</span> <span class="p">{};</span>
</span><span class='line'>
</span><span class='line'><span class="c1">// New instance.</span>
</span><span class='line'><span class="kd">var</span> <span class="nx">justACat</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">Cat</span><span class="p">();</span>
</span><span class='line'>
</span><span class='line'><span class="c1">// Capitalized function variable name.</span>
</span><span class='line'><span class="kd">var</span> <span class="nx">BlackCat</span> <span class="o">=</span> <span class="kd">function</span><span class="p">()</span> <span class="p">{};</span>
</span><span class='line'>
</span><span class='line'><span class="c1">// New instance.</span>
</span><span class='line'><span class="kd">var</span> <span class="nx">felix</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">BlackCat</span><span class="p">();</span>
</span></code></pre></td></tr></table></div></figure>


<h2>3. Prototype Property</h2>

<p>The property <code>prototype</code> is an <em>internal property</em> and all internal properties are not accessible via code, they defines behavior of code. ECRMAScript defines multiple internal properties indicating them by <em>double square-bracket notation</em> as <code>[[internal_property]]</code>.</p>

<blockquote><p>You can think of a <span style="color:#B90504">prototype</span> as a recipe for an object.</p><footer><strong>Nicholas C. Zakas</strong> <cite><a href='http://shop.oreilly.com/product/9781593275402.do'>The Principles of Object-Oriented JavaScript</a></cite></footer></blockquote>


<h5>Prototype property using object literal</h5>

<p>Create an object via <em>object literal</em> notation in a browser console (Safari in this case):</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
</pre></td><td class='code'><pre><code class='javascript'><span class='line'><span class="o">&gt;</span> <span class="kd">var</span> <span class="nx">cat</span> <span class="o">=</span> <span class="p">{};</span>
</span><span class='line'><span class="o">&gt;</span> <span class="nx">cat</span>
</span><span class='line'><span class="o">&lt;</span> <span class="nb">Object</span>
</span><span class='line'>    <span class="nx">__proto__</span><span class="o">:</span> <span class="nb">Object</span>
</span></code></pre></td></tr></table></div></figure>


<p>Typing the name of the variable will show type of the object which is <code>Object</code>, and the property <code>__proto__</code>. This <em>property</em> is supported by WebKit based browser and allows to both read and write to the <code>[[Prototype]]</code> property.</p>

<p>The property <code>[[Prototype]]</code> is a pointer back to the prototype object used by the instance. In the example the property <code>__proto__</code> points to the <em>prototype object</em> <code>Object</code> because it has been created via object literal. Object <code>cat</code> inherits properties directly from <code>Object.prototype</code>.</p>

<h5>Prototype property using function constructor</h5>

<p>Now let&rsquo;s define a <em>constructor function</em> named <code>Cat</code> and create an object via the <code>new</code> operator:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
</pre></td><td class='code'><pre><code class='javascript'><span class='line'><span class="o">&gt;</span> <span class="kd">function</span> <span class="nx">Cat</span><span class="p">(){};</span>
</span><span class='line'><span class="o">&gt;</span> <span class="nx">Cat</span><span class="p">.</span><span class="nx">prototype</span><span class="p">.</span><span class="nx">name</span> <span class="o">=</span> <span class="s1">&#39;just a cat&#39;</span><span class="p">;</span>
</span><span class='line'><span class="o">&gt;</span> <span class="kd">var</span> <span class="nx">cat</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">Cat</span><span class="p">();</span>
</span><span class='line'><span class="o">&gt;</span> <span class="nx">cat</span>
</span><span class='line'><span class="o">&lt;</span> <span class="nx">Cat</span>
</span><span class='line'>    <span class="nx">__proto__</span><span class="o">:</span> <span class="nx">Cat</span>
</span><span class='line'>        <span class="nx">constructor</span><span class="o">:</span> <span class="kd">function</span> <span class="nx">Cat</span><span class="p">()</span> <span class="p">{}</span>
</span><span class='line'>        <span class="nx">name</span><span class="o">:</span> <span class="s2">&quot;just a cat&quot;</span>
</span><span class='line'>        <span class="nx">__proto__</span><span class="o">:</span> <span class="nb">Object</span>
</span></code></pre></td></tr></table></div></figure>


<p>Typing <code>cat</code> something different happens: the variable <code>cat</code> contains a reference to an instance of type <code>Cat</code>, the property <code>__proto__</code> is of type <code>Cat</code> and, in turn, it has a property <code>constructor</code>, a property <code>name</code> (which is the one define on the <code>prototype</code> property of the constructor function) and, in the end, another <code>__proto__</code> prototype of type <code>Object</code>.</p>

<h4>Prototype property in a nutshell</h4>

<p>In JavaScript an object is defined by a set of pairs (property,value), prototype is an <em>inner hidden property</em> whose value is an object representing the <em>prototype chain</em>. The <em>prototype</em> property is a way to share common properties among objects in a <em>prototype chain</em> in order to build a hierarchy.</p>

<p>The <code>__proto__</code> property reference the prototype chain used to return property values. The prototype chain determines from where an object inherits properties, if an object does not have a property, it is searched in the prototype chain, this is called <strong>delegation</strong> until the property is reached otherwise the return value is <code>undefined</code>.</p>

<h3>3.1 Keep track of the prototype</h3>

<p>An instance uses the <em>internal property</em> <code>[[Prototype]]</code> to keep track of its prototype, that is <em>the object it descends from</em>. Everything an object wants to share must be defined inside the prototype property.</p>

<h4>Prototype property and constructors</h4>

<p>The paragraph <a href="#function_constructor">function constructor</a> has introduced a way to share common properties among objects created by the same constructor function. For instance:</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
</pre></td><td class='code'><pre><code class='javascript'><span class='line'><span class="s1">&#39;use strict&#39;</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'><span class="kd">function</span> <span class="nx">Cat</span><span class="p">()</span> <span class="p">{};</span>
</span><span class='line'>
</span><span class='line'><span class="nx">Cat</span><span class="p">.</span><span class="nx">prototype</span><span class="p">.</span><span class="nx">language</span> <span class="o">=</span> <span class="s1">&#39;meow&#39;</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'><span class="nx">Cat</span><span class="p">.</span><span class="nx">prototype</span><span class="p">.</span><span class="nx">legs</span> <span class="o">=</span> <span class="mi">4</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'><span class="nx">Cat</span><span class="p">.</span><span class="nx">prototype</span><span class="p">.</span><span class="nx">toString</span> <span class="o">=</span> <span class="kd">function</span><span class="p">()</span> <span class="p">{</span>
</span><span class='line'>  <span class="k">return</span> <span class="s1">&#39;language: &#39;</span> <span class="o">+</span> <span class="k">this</span><span class="p">.</span><span class="nx">language</span> <span class="o">+</span> <span class="s1">&#39; and &#39;</span> <span class="o">+</span> <span class="k">this</span><span class="p">.</span><span class="nx">legs</span> <span class="o">+</span> <span class="s1">&#39; legs.&#39;</span><span class="p">;</span>
</span><span class='line'><span class="p">};</span>
</span><span class='line'>
</span><span class='line'><span class="kd">var</span> <span class="nx">felix</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">Cat</span><span class="p">();</span>
</span><span class='line'><span class="nx">felix</span><span class="p">.</span><span class="nx">toString</span><span class="p">();</span>
</span></code></pre></td></tr></table></div></figure>


<p>the function constructor <code>Cat</code> has been defined via <em>object literal</em> notation and then its <em>prototype</em> is augmented with some properties in order to not be repeated every time an object of type <code>Cat</code> is created. In the example the function <code>toString()</code> is overridden so, when invoked, the one from <code>Cat.prototype</code> will be used instead of the one from <code>Object.prototype</code>.</p>

<p>Typing <code>felix</code> in the console the referenced object is shown.</p>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
</pre></td><td class='code'><pre><code class='javascript'><span class='line'><span class="nx">felix</span>
</span><span class='line'><span class="nx">Cat</span>
</span><span class='line'>    <span class="nx">__proto__</span><span class="o">:</span> <span class="nx">Cat</span>
</span><span class='line'>        <span class="nx">constructor</span><span class="o">:</span> <span class="kd">function</span> <span class="nx">Cat</span><span class="p">()</span> <span class="p">{}</span>
</span><span class='line'>        <span class="nx">language</span><span class="o">:</span> <span class="s2">&quot;meow&quot;</span>
</span><span class='line'>        <span class="nx">legs</span><span class="o">:</span> <span class="mi">4</span>
</span><span class='line'>        <span class="nx">toString</span><span class="o">:</span> <span class="kd">function</span> <span class="p">()</span> <span class="p">{</span>
</span><span class='line'>        <span class="nx">__proto__</span><span class="o">:</span> <span class="nb">Object</span>
</span></code></pre></td></tr></table></div></figure>


<p>The instance referenced by <code>felix</code> is of type <code>Cat</code> as expected, along with the properties <em>attached</em> to <code>Cat.prototype</code>.</p>

<h3>References</h3>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Kii Web Application]]></title>
    <link href="http://blackat.github.io/blog/2014/12/11/kii-web-application/"/>
    <updated>2014-12-11T19:32:27+01:00</updated>
    <id>http://blackat.github.io/blog/2014/12/11/kii-web-application</id>
    <content type="html"><![CDATA[<p>The current <strong>tut</strong> explore how to create a simple mobile application with HTML5, CSS3 and JavaScript based on the new Kii Javascript SDK. Basically Kii Corporation offers a rich cloud mobile backend to help the development of a mobile application providing some services out of the box such as user registration and login. Then the application will be wrapped by Apache Cordova to obtain a deployable app for iOS and Android in a hybrid fashion.</p>

<p><img class="center" src="http://blackat.github.io/images/posts/genymotion-get-your-box.png"></p>

<!-- more -->


<h2>Preview of the application in Plunker</h2>

<p>A preview of the web application that is going to be implemented can be seen and tested in <a href="http://plnkr.co/edit/mSrWyzmmgOeSzCDKRWk8?p=preview" target="_blank">Plunker</a> using <code>jon/dohh</code> as username/password or just registering a new user. Password must be at least 4 charaters and special ones are not allowed</p>

<p>In order to make it work I had to brutally copy/paste the content of the Kii Javascript SDK in a file because Plunker does not allow file upload.</p>

<h2>Build steps</h2>

<h3>1. Create a Kii cloud application</h3>

<p>First of all create a Kii account and then a new Kii application, put the name and select the HTML5 logo. Now download the <a href="https://developer.kii.com/v2/apps/5510/downloads-templates" target="_blank">Kii Javascript SDK</a>.</p>

<h3>2. Clone Github repository</h3>

<p>Clone the repository containing the simple application</p>

<pre><code>$ git clone https://github.com/blackat/kii-sdk-js-101.git
</code></pre>

<p>The application is the same application has been implemented in <a href="http://plnkr.co/edit/mSrWyzmmgOeSzCDKRWk8?p=preview" target="_blank">Plunker</a> with the following structure:</p>

<pre><code>├── css
│   ├── bootstrap.min.css
│   └── style.css                   # custom style
├── fonts
│   └── CherryCreamSoda.ttf         # a fancy font
├── index.html                      # single page of the web application
├── js
│   ├── angular.min.js
│   ├── angular.min.js.map
│   ├── kiisdk.js                   # Kii JavaScript SDK
│   └── script.js                   # custom script for Angular controllers
├── package.json
└── server.js                       # server side configuration
</code></pre>

<p>In the <code>index.html</code> a minimal form has been implemented to allow login and registration of the user. Just to make the UI a bit more fancy and easy to develop, Boostrap and AngularJS frameworks have been added.</p>

<h4>2.1 Kii JavaScript SDK</h4>

<p>The SDK has been used to perform <em>login</em> and <em>registration</em> action.</p>

<figure class='code'><figcaption><span>js/script.js</span> — <a href='https://github.com/blackat/kii-sdk-js-101/blob/master/js/script.js'>Link</a></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
</pre></td><td class='code'><pre><code class='javascript'><span class='line'><span class="nx">$scope</span><span class="p">.</span><span class="nx">login</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">()</span> <span class="p">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="nx">KiiUser</span><span class="p">.</span><span class="nx">authenticate</span><span class="p">(</span><span class="nx">$scope</span><span class="p">.</span><span class="nx">user</span><span class="p">.</span><span class="nx">username</span><span class="p">,</span> <span class="nx">$scope</span><span class="p">.</span><span class="nx">user</span><span class="p">.</span><span class="nx">password</span><span class="p">,</span> <span class="p">{</span>
</span><span class='line'>        <span class="c1">// Called on successful registration</span>
</span><span class='line'>        <span class="nx">success</span><span class="o">:</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">theUser</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>
</span><span class='line'>        <span class="p">},</span>
</span><span class='line'>
</span><span class='line'>        <span class="c1">// Called on a failed authentication</span>
</span><span class='line'>        <span class="nx">failure</span><span class="o">:</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">theUser</span><span class="p">,</span> <span class="nx">errorString</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>
</span><span class='line'>        <span class="p">}</span>
</span><span class='line'>    <span class="p">})</span>
</span><span class='line'><span class="p">};</span>
</span></code></pre></td></tr></table></div></figure>


<p>Some details has been remove just to focus on the <code>authenticate</code> function. Once the credential has been sent to the cloud one of the two functions will be called according to the outcome of the authentication.</p>

<p>The registration function is a bit different, a new <code>KiiUser</code> object has to be created with the data coming from the <code>form</code> and then the function <code>register</code> has to be called. As for the <code>login</code> function two callbacks are available to manage possible process outcomes.</p>

<figure class='code'><figcaption><span>js/script.js</span> — <a href='https://github.com/blackat/kii-sdk-js-101/blob/master/js/script.js'>Link</a></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
</pre></td><td class='code'><pre><code class='javascript'><span class='line'><span class="nx">$scope</span><span class="p">.</span><span class="nx">register</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">()</span> <span class="p">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="c1">// Create the KiiUser object</span>
</span><span class='line'>    <span class="kd">var</span> <span class="nx">user</span> <span class="o">=</span> <span class="nx">KiiUser</span><span class="p">.</span><span class="nx">userWithUsername</span><span class="p">(</span><span class="nx">$scope</span><span class="p">.</span><span class="nx">user</span><span class="p">.</span><span class="nx">username</span><span class="p">,</span> <span class="nx">$scope</span><span class="p">.</span><span class="nx">user</span><span class="p">.</span><span class="nx">password</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="c1">// Register the user, defining callbacks for when the process completes</span>
</span><span class='line'>    <span class="nx">user</span><span class="p">.</span><span class="nx">register</span><span class="p">({</span>
</span><span class='line'>        <span class="c1">// Called on successful registration</span>
</span><span class='line'>        <span class="nx">success</span><span class="o">:</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">theUser</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>
</span><span class='line'>        <span class="p">},</span>
</span><span class='line'>        <span class="c1">// Called on a failed registration</span>
</span><span class='line'>        <span class="nx">failure</span><span class="o">:</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">theUser</span><span class="p">,</span> <span class="nx">errorString</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>
</span><span class='line'>        <span class="p">}</span>
</span><span class='line'>    <span class="p">});</span>
</span><span class='line'><span class="p">};</span>
</span></code></pre></td></tr></table></div></figure>


<h3>3. Local test with node.js</h3>

<p>In order to locally test in a browser the application <code>node.js</code> can be used. Download and install <a href="http://nodejs.org/download/" target="_blank">node.js</a>. On mac use <a href="http://brew.sh/"target="_blank">homebrew</a></p>

<pre><code>$ brew install node
</code></pre>

<p>once done use <code>npm</code> to install modules declared in <code>package.json</code></p>

<pre><code>$ npm install -g
</code></pre>

<p>where <code>-g</code> option means glabally, remove it to have all the modules installed locally in a folder named <code>node_modules</code>. Then, in the folder where the repository has been cloned, run the command</p>

<pre><code>$ node server.js
</code></pre>

<p>and type in a browser tab <code>http://127.0.0.1:5000/</code> to load the web page.</p>

<h3>4. PhoneGap/Apache Cordova Installation</h3>

<p>PhoneGap wraps a native web application written in HTML, CSS and JavaScript in a native application of a given platform such as iOS, Android, Windows8 and more.</p>

<p><a href="http://www.smashingmagazine.com/2014/02/11/four-ways-to-build-a-mobile-app-part3-phonegap/">Here</a> it is possible to find a more detailed tutorial about hot to build a mobile application using PhoneGap.</p>

<h4>PhoneGap vs Cordova</h4>

<blockquote><p>PhoneGap is a distribution of Apache Cordova. You can think of Apache Cordova as the engine that powers PhoneGap, similar to how WebKit is the engine that powers Chrome or Safari.</p></blockquote>

<p>More <a href="http://phonegap.com/2012/03/19/phonegap-cordova-and-what%E2%80%99s-in-a-name/">here</a></p>

<h4>Prepare the environment</h4>

<p><a href="http://nodejs.org/download/">Install Node.js</a> if not yet done.</p>

<p>Install Apache Cordova</p>

<pre><code>npm install -g cordova
</code></pre>

<p>Optional, to debug install <a href="http://www.raymondcamden.com/index.cfm/2013/11/5/Ripple-is-Reborn">Apache Ripple emulator</a></p>

<pre><code>$ npm install -g ripple-emulator
</code></pre>

<p>Install Android SDK</p>

<pre><code>$ brew install android
</code></pre>

<p>Install &lsquo;&#8217;actual SDK stuff&rsquo;&#8217;</p>

<pre><code>$ android
</code></pre>

<p><a href="https://www.genymotion.com/#!/download">Install Genymotion</a> to test the mobile application for Android devices.</p>

<h4>Genymotion</h4>

<p>Genymotion offers a better and more straight forward way to test an Android app than the native emulator. Once done register one or more virtual divices according to your preferences.</p>

<p><img class="center" src="http://blackat.github.io/images/posts/genymotion-devices.png"></p>

<p>Pay attention about the specified <code>API version</code> of the virtual devices because it must match the one installed previously when <code>android</code> command has been run to install &lsquo;&#8217;actual SDK stuff&rsquo;&lsquo;, both are at version 21.</p>

<p><img class="center" src="http://blackat.github.io/images/posts/android-sdk.png"></p>

<h3>5. Create the Apache Cordova application</h3>

<h4>Step A - Create a Cordova project</h4>

<p>Run the command</p>

<pre><code>$ cordova create kii101phonegap com.kii.phonegap Kii101PhoneGap
</code></pre>

<p>This command will create a project named <em>Kii101PhoneGap</em> in the folder <code>kii101phonegap</code>.</p>

<h4>Step B - Add project files</h4>

<p>Copy the cloned repository content under the <code>www</code> into the project just created.</p>

<pre><code>├── css
│   ├── bootstrap.min.css
│   └── style.css
├── fonts
│       └── CherryCreamSoda.ttf
├── index.html
└── js
    ├── angular.min.js
    ├── angular.min.js.map
    ├── kiisdk.js
    └── script.js
</code></pre>

<h4>Step C - Add platforms</h4>

<p>Switch to folder <code>kii101phonegap</code> and add the platforms against which the test will be done, for instance iOS and Android</p>

<pre><code>$ cordova platform add ios
$ cordova platform add android
</code></pre>

<h4>Step D - Build and emulate</h4>

<p>Build the application and test it in <strong>iOS</strong> platform running</p>

<pre><code>$ cordova build ios
$ cordova emulate ios
</code></pre>

<p>after the project have been built, an emulation window opens showing the developed application.</p>

<p>For <strong>Android</strong> it is a bit different, before start the Genymotion virtual device created in one of the previous steps, then in the command line type</p>

<pre><code>$ adb devices
</code></pre>

<p>and see how the Genymotion virtual device is seen as a real one</p>

<pre><code>List of devices attached
192.168.56.101:5555 device
</code></pre>

<p>so run the command</p>

<pre><code>$ cordova run android
</code></pre>

<p>and the application will be deployed into the Genymotion device.</p>

<h2>From the Kii Team</h2>

<p>If you&rsquo;re interested in more samples that use <strong>Kii Cloud</strong> please take a look at the <a href="https://github.com/KiiCorp">GitHub page</a> from the Kii team. Also, if you&rsquo;re interested in other platforms, please check out their samples section available <a href="http://docs.kii.com/en/samples/">here</a>.</p>

<h2>Trobleshooting</h2>

<h4>Android target</h4>

<p>Sometimes could happen that a prject has been created when a previuos <code>android-sdk</code> was installed, then having created a new device based on a more recent <code>API</code> the following error arises</p>

<pre><code>ERROR: Error: Please install Android target 19 (the Android newest SDK).
Make sure you have the latest Android tools installed as well.
Run "android" from your command-line to install/update any missing SDKs or tools.
</code></pre>

<p>In the folder <code>kii101phonegap/platforms/android</code> of the Cordova application check the following files and keep android-sdk version consistent.</p>

<pre><code>├── AndroidManifest.xml     # &lt;uses-sdk&gt; tag
├── local.properties        # location of the SDK. This is only used by Ant
├── project.properties      # project target
</code></pre>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Fullstack Javascript Web Application Part 2]]></title>
    <link href="http://blackat.github.io/blog/2014/10/03/fullstack-javascript-web-application-part-2/"/>
    <updated>2014-10-03T23:52:35+02:00</updated>
    <id>http://blackat.github.io/blog/2014/10/03/fullstack-javascript-web-application-part-2</id>
    <content type="html"><![CDATA[<p>The single page web application will be enriched with a database support, a build system with dependencies management and a testing framework.</p>

<p><img class="center" src="http://blackat.github.io/images/posts/popcorn-time-screenshot.png"></p>

<p><a href="http://gruntjs.com/" title="Grunt homepage">Grunt</a> task runner and <a href="bower.io" title="Bower homepage">Bower</a> package management system will be configured. Then <a href="http://www.mongodb.org/" title="MongoDB homepage">Mongodb</a> with a persistent model will be added, finally <a href="http://jasmine.github.io/" title="Jasmine homepage">Jasmine</a> and <a href="http://karma-runner.github.io/0.12/index.html" title="Karma homepage">Karma</a> will support tests and their execution.</p>

<!-- more -->


<h2>1. Continuos build integration</h2>

<p><a href="http://gruntjs.com/" title="Grunt homepage">Grunt</a> is a <em>task runner</em>, means it runs pre-defined tasks and custom tasks defined by the user in order to achieve a certain goal such as the deployment in production, running unit and end-to-end (e2e) tests and so on.</p>

<p><a href="bower.io" title="Bower homepage">Bower</a> is a package management system quite widespread in the javascript community added to manage packages for client-side programming. It depends on <em>Node.js</em> and <em>npm</em>.</p>

<h3>1.1 Grunt Task Runner</h3>

<figure class='code'><figcaption><span>package.json</span> — <a href='https://github.com/blackat/popcorn-time-express-angular-mongodb-grunt/blob/master/package.json'>Link</a></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
</pre></td><td class='code'><pre><code class='json'><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="nt">&quot;name&quot;</span><span class="p">:</span> <span class="s2">&quot;popcorn-time-backend&quot;</span><span class="p">,</span>
</span><span class='line'>    <span class="nt">&quot;description&quot;</span><span class="p">:</span> <span class="s2">&quot;a web application based on node, express, mongodb and grunt task runner with bower dependencies manager&quot;</span><span class="p">,</span>
</span><span class='line'>    <span class="nt">&quot;version&quot;</span><span class="p">:</span> <span class="s2">&quot;0.0.1&quot;</span><span class="p">,</span>
</span><span class='line'>    <span class="nt">&quot;private&quot;</span><span class="p">:</span> <span class="kc">true</span><span class="p">,</span>
</span><span class='line'>    <span class="nt">&quot;dependencies&quot;</span><span class="p">:</span> <span class="p">{</span>
</span><span class='line'>        <span class="nt">&quot;express&quot;</span><span class="p">:</span> <span class="s2">&quot;4.0.x&quot;</span><span class="p">,</span>
</span><span class='line'>        <span class="nt">&quot;ejs&quot;</span><span class="p">:</span> <span class="s2">&quot;~0.8.4&quot;</span>
</span><span class='line'>    <span class="p">},</span>
</span><span class='line'>    <span class="nt">&quot;devDependencies&quot;</span><span class="p">:</span> <span class="p">{</span>
</span><span class='line'>        <span class="nt">&quot;grunt&quot;</span><span class="p">:</span> <span class="s2">&quot;~0.4.5&quot;</span><span class="p">,</span>
</span><span class='line'>        <span class="nt">&quot;grunt-contrib-jshint&quot;</span><span class="p">:</span> <span class="s2">&quot;~0.10.0&quot;</span><span class="p">,</span>
</span><span class='line'>        <span class="nt">&quot;grunt-contrib-uglify&quot;</span><span class="p">:</span> <span class="s2">&quot;~0.5.0&quot;</span><span class="p">,</span>
</span><span class='line'>        <span class="nt">&quot;load-grunt-tasks&quot;</span><span class="p">:</span> <span class="s2">&quot;~0.2.0&quot;</span><span class="p">,</span>
</span><span class='line'>        <span class="nt">&quot;grunt-express-server&quot;</span><span class="p">:</span> <span class="s2">&quot;~0.4.19&quot;</span><span class="p">,</span>
</span><span class='line'>        <span class="nt">&quot;grunt-open&quot;</span><span class="p">:</span> <span class="s2">&quot;~0.2.0&quot;</span><span class="p">,</span>
</span><span class='line'>        <span class="nt">&quot;time-grunt&quot;</span><span class="p">:</span> <span class="s2">&quot;~0.2.1&quot;</span><span class="p">,</span>
</span><span class='line'>        <span class="nt">&quot;load-grunt-tasks&quot;</span><span class="p">:</span> <span class="s2">&quot;~0.2.0&quot;</span>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>Modify the list of modules in order to include the dependencies to Grunt and Grunt plugins in <code>devDependencies</code>.</p>

<p>Previous dependencies have been removed and will be managed by Bower later on. <code>package.json</code> manages just Grunt and Bower dependencies necessary to manage the all project lifecycle.</p>

<h3>1.2 Grunt file configuration</h3>

<figure class='code'><figcaption><span>Gruntfile.js</span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
<span class='line-number'>26</span>
<span class='line-number'>27</span>
<span class='line-number'>28</span>
<span class='line-number'>29</span>
<span class='line-number'>30</span>
<span class='line-number'>31</span>
<span class='line-number'>32</span>
<span class='line-number'>33</span>
<span class='line-number'>34</span>
<span class='line-number'>35</span>
<span class='line-number'>36</span>
<span class='line-number'>37</span>
<span class='line-number'>38</span>
<span class='line-number'>39</span>
</pre></td><td class='code'><pre><code class='javascript'><span class='line'><span class="s1">&#39;use strict&#39;</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'><span class="c1">// 1. Wrapper function</span>
</span><span class='line'><span class="nx">module</span><span class="p">.</span><span class="nx">exports</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">grunt</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="c1">// replace step 3</span>
</span><span class='line'>    <span class="nx">require</span><span class="p">(</span><span class="s1">&#39;load-grunt-tasks&#39;</span><span class="p">)(</span><span class="nx">grunt</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="c1">// 2. Project and tasks configuration</span>
</span><span class='line'>    <span class="nx">grunt</span><span class="p">.</span><span class="nx">initConfig</span><span class="p">({</span>
</span><span class='line'>        <span class="nx">pkg</span><span class="o">:</span> <span class="nx">grunt</span><span class="p">.</span><span class="nx">file</span><span class="p">.</span><span class="nx">readJSON</span><span class="p">(</span><span class="s1">&#39;package.json&#39;</span><span class="p">),</span>
</span><span class='line'>        <span class="nx">express</span><span class="o">:</span> <span class="p">{</span>
</span><span class='line'>            <span class="nx">options</span><span class="o">:</span> <span class="p">{</span>
</span><span class='line'>                <span class="nx">port</span><span class="o">:</span> <span class="nx">process</span><span class="p">.</span><span class="nx">env</span><span class="p">.</span><span class="nx">PORT</span> <span class="o">||</span> <span class="mi">9000</span>
</span><span class='line'>            <span class="p">},</span>
</span><span class='line'>            <span class="nx">dev</span><span class="o">:</span> <span class="p">{</span>
</span><span class='line'>                <span class="nx">script</span><span class="o">:</span> <span class="s1">&#39;server.js&#39;</span><span class="p">,</span>
</span><span class='line'>                <span class="nx">debug</span><span class="o">:</span> <span class="kc">true</span>
</span><span class='line'>            <span class="p">}</span>
</span><span class='line'>        <span class="p">},</span>
</span><span class='line'>        <span class="nx">open</span><span class="o">:</span> <span class="p">{</span>
</span><span class='line'>            <span class="nx">server</span><span class="o">:</span> <span class="p">{</span>
</span><span class='line'>                <span class="nx">url</span><span class="o">:</span> <span class="s1">&#39;http://localhost:&lt;%= express.options.port %&gt;&#39;</span>
</span><span class='line'>            <span class="p">}</span>
</span><span class='line'>        <span class="p">}</span>
</span><span class='line'>    <span class="p">});</span>
</span><span class='line'>
</span><span class='line'>
</span><span class='line'>    <span class="c1">// 3. Load grunt plugins and tasks</span>
</span><span class='line'>
</span><span class='line'>    <span class="c1">// 4. Custom tasks</span>
</span><span class='line'>    <span class="nx">grunt</span><span class="p">.</span><span class="nx">registerTask</span><span class="p">(</span><span class="s1">&#39;serve&#39;</span><span class="p">,</span> <span class="s1">&#39;default is dev environment&#39;</span><span class="p">,</span> <span class="kd">function</span><span class="p">(</span><span class="nx">target</span><span class="p">){</span>
</span><span class='line'>
</span><span class='line'>        <span class="nx">grunt</span><span class="p">.</span><span class="nx">task</span><span class="p">.</span><span class="nx">run</span><span class="p">([</span>
</span><span class='line'>            <span class="s1">&#39;express:dev&#39;</span><span class="p">,</span>
</span><span class='line'>            <span class="s1">&#39;open&#39;</span>
</span><span class='line'>        <span class="p">]);</span>
</span><span class='line'>    <span class="p">});</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>Add <code>Gruntfile.js</code> to the project used to define tasks and load plugins. Grunt configuration file is made of four parts</p>

<ol>
<li>Wrapper function: when Grunt is run from the CLI, it looks for the configuration file in order to load plugins and run the required task. Grunt</li>
<li>Project and tasks configuration: here plugin&rsquo;s tasks are defined in order to be reused later on. For instance <code>express</code> Grunt plugin has been declared in the <code>package.json</code>, along with the plugin come some tasks which could be configured and used. <code>express</code> plugin task is declared and configured as the <code>open</code> plugin&rsquo;s task.</li>
<li><p>Load grunt plugins and tasks: for instance <code>express</code> plugin must be declared under <code>devDependencies</code> in <code>package.json</code>, configured in <code>Gruntfile.js</code> but even loaded. This section is done for loading such plugins which define tasks such as  <code>grunt.loadNpmTasks('grunt-express-server');</code>.</p>

<p> When the project grows there could be many lines each one to load a plugin, this can become quite annoying and even result in a good amount of boiler-plate code. As alternative solution, use <a href="(https://github.com/sindresorhus/load-grunt-tasks)" title="Load grunt task plugin">load-grunt-task</a> plugin in order to automatically load plugins from <code>dependencies</code> and <code>devDependencies</code> in <code>package.json</code>, so just <em>load plugins in one line</em>.</p></li>
<li><p>Custom tasks: here define your task as aggregation of tasks defined and configured in section number 2.</p></li>
</ol>


<h3>1.3 First run</h3>

<p>Run <code>npm install</code> to install modules locally or <code>npm install -g</code> to install modules globally then run <code>grunt serve</code> task.</p>

<h3>1.4 Bower Package Management System</h3>

<figure class='code'><figcaption><span>bower.json</span> — <a href='https://github.com/blackat/popcorn-time-express-angular-mongodb-grunt/blob/master/bower.json'>Link</a></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
</pre></td><td class='code'><pre><code class='javascript'><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="s2">&quot;name&quot;</span><span class="o">:</span> <span class="s2">&quot;popcorn-time-backend-bower&quot;</span><span class="p">,</span>
</span><span class='line'>    <span class="s2">&quot;version&quot;</span><span class="o">:</span> <span class="s2">&quot;0.0.1&quot;</span><span class="p">,</span>
</span><span class='line'>    <span class="s2">&quot;homepage&quot;</span><span class="o">:</span> <span class="s2">&quot;https://github.com/blackat/popcorn-time-express-angular-mongodb-grunt&quot;</span><span class="p">,</span>
</span><span class='line'>    <span class="s2">&quot;authors&quot;</span><span class="o">:</span> <span class="p">[</span>
</span><span class='line'>        <span class="s2">&quot;blackat &lt;blackat@somewhere.world&gt;&quot;</span>
</span><span class='line'>    <span class="p">],</span>
</span><span class='line'>    <span class="s2">&quot;description&quot;</span><span class="o">:</span> <span class="s2">&quot;A web application based on node, express, mongodb and grunt task runner with bower dependencies manager&quot;</span><span class="p">,</span>
</span><span class='line'>    <span class="s2">&quot;moduleType&quot;</span><span class="o">:</span> <span class="p">[</span>
</span><span class='line'>        <span class="s2">&quot;node&quot;</span>
</span><span class='line'>    <span class="p">],</span>
</span><span class='line'>    <span class="s2">&quot;license&quot;</span><span class="o">:</span> <span class="s2">&quot;MIT&quot;</span><span class="p">,</span>
</span><span class='line'>    <span class="s2">&quot;ignore&quot;</span><span class="o">:</span> <span class="p">[</span>
</span><span class='line'>        <span class="s2">&quot;**/.*&quot;</span><span class="p">,</span>
</span><span class='line'>        <span class="s2">&quot;node_modules&quot;</span><span class="p">,</span>
</span><span class='line'>        <span class="s2">&quot;bower_components&quot;</span><span class="p">,</span>
</span><span class='line'>        <span class="s2">&quot;app/bower_components&quot;</span><span class="p">,</span>
</span><span class='line'>        <span class="s2">&quot;test&quot;</span><span class="p">,</span>
</span><span class='line'>        <span class="s2">&quot;tests&quot;</span>
</span><span class='line'>    <span class="p">]</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>Type <code>npm install -g bower</code> to install <strong>Bower</strong> globally, then <code>bower init</code> in the root folder of the current project to have <code>bower.json</code> <em>manifest</em> file created and initialized with some basic information.</p>

<h4>1.4.1 Bower in a Nutshell</h4>

<p><em>Bower</em> manages front-end components (css, html, js), <em>npm</em> manages Javascript modules called packages. Some components can be installed by <em>npm</em> as well but step by step a cleaner difference between backend and frontend elements is arising. <em>Ember</em> updates for instance are currently published only under <em>Bower</em>. More on the difference  <a href="http://tech.pro/tutorial/1190/package-managers-an-introductory-guide-for-the-uninitiated-front-end-developer">here</a>.</p>

<p>Thus <code>package.json</code> is used to install <em>Node</em> modules such as <em>Grunt</em>, <em>Express</em> and so on, instead <code>bower.json</code> for all the client-side libraries such as <em>Angular</em>, <em>Bootstrap</em> and all the components could be required by <code>index.html</code> page.</p>

<h4>1.4.2 Configure Grunt Wiredep Task</h4>

<figure class='code'><figcaption><span>package.json</span> — <a href='https://github.com/blackat/popcorn-time-express-angular-mongodb-grunt/blob/master/package.json'>Link</a></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
</pre></td><td class='code'><pre><code class='json'><span class='line'><span class="err">},</span>
</span><span class='line'>    <span class="s2">&quot;devDependencies&quot;</span><span class="err">:</span> <span class="p">{</span>
</span><span class='line'>        <span class="err">...</span>
</span><span class='line'>        <span class="nt">&quot;grunt-wiredep&quot;</span><span class="p">:</span> <span class="s2">&quot;~1.9.x&quot;</span><span class="p">,</span>
</span><span class='line'>        <span class="err">...</span>
</span><span class='line'>    <span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>Add <code>grunt-wiredep</code> to <code>package.json</code>. It is the <em>grunt task</em> will inject UI dependencies. Then add and configure the grunt task in <code>Gruntfile.js</code> as follows:</p>

<figure class='code'><figcaption><span>Gruntfile.js</span> — <a href='https://github.com/blackat/popcorn-time-express-angular-mongodb-grunt/blob/master/Gruntfile.js'>Link</a></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
</pre></td><td class='code'><pre><code class='json'><span class='line'><span class="err">...</span>
</span><span class='line'><span class="err">grunt.initConfig(</span><span class="p">{</span>
</span><span class='line'>    <span class="err">...</span>
</span><span class='line'>    <span class="err">//</span> <span class="err">Download</span> <span class="err">and</span> <span class="err">inject</span> <span class="err">Bower</span> <span class="err">components</span> <span class="err">into</span> <span class="err">the</span> <span class="err">app</span>
</span><span class='line'>    <span class="err">wiredep:</span> <span class="err">{</span>
</span><span class='line'>        <span class="err">target:</span> <span class="err">{</span>
</span><span class='line'>            <span class="err">src:</span> <span class="err">&#39;app/views/**/*.html&#39;,</span>
</span><span class='line'>            <span class="err">options:</span> <span class="err">{</span>
</span><span class='line'>                <span class="err">cwd:</span> <span class="err">&#39;&#39;,</span>
</span><span class='line'>                <span class="err">dependencies:</span> <span class="err">true,</span>
</span><span class='line'>                <span class="err">devDependencies:</span> <span class="err">false,</span>
</span><span class='line'>                <span class="err">exclude:</span> <span class="err">[&#39;app/bower_components/bootstrap/dist/js/bootstrap.js&#39;]</span>
</span><span class='line'>            <span class="p">}</span>
</span><span class='line'>        <span class="err">}</span>
</span><span class='line'>    <span class="err">}</span>
</span><span class='line'><span class="err">});</span>
</span><span class='line'>    <span class="err">...</span>
</span><span class='line'><span class="err">grunt.registerTask(&#39;serve&#39;,</span> <span class="err">&#39;default</span> <span class="err">is</span> <span class="err">dev</span> <span class="err">environment&#39;,</span> <span class="err">function</span> <span class="err">(target)</span> <span class="p">{</span>
</span><span class='line'>    <span class="err">grunt.task.run([</span>
</span><span class='line'>        <span class="err">&#39;wiredep&#39;,</span>
</span><span class='line'>        <span class="err">&#39;express:dev&#39;,</span>
</span><span class='line'>        <span class="err">&#39;open&#39;,</span>
</span><span class='line'>        <span class="err">&#39;express-keepalive&#39;</span>
</span><span class='line'>    <span class="err">]);</span>
</span><span class='line'><span class="p">}</span><span class="err">);</span>
</span></code></pre></td></tr></table></div></figure>


<h4>1.4.3 Inject Bower Components</h4>

<figure class='code'><figcaption><span>bower.json</span> — <a href='https://github.com/blackat/popcorn-time-express-angular-mongodb-grunt/blob/master/bower.json'>Link</a></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
</pre></td><td class='code'><pre><code class='json'><span class='line'><span class="err">...</span>
</span><span class='line'><span class="s2">&quot;dependencies&quot;</span><span class="err">:</span> <span class="p">{</span>
</span><span class='line'>    <span class="nt">&quot;angular&quot;</span><span class="p">:</span> <span class="s2">&quot;&gt;=1.2.*&quot;</span><span class="p">,</span>
</span><span class='line'>    <span class="nt">&quot;angular-resource&quot;</span><span class="p">:</span> <span class="s2">&quot;&gt;=1.2.*&quot;</span><span class="p">,</span>
</span><span class='line'>    <span class="nt">&quot;angular-route&quot;</span><span class="p">:</span> <span class="s2">&quot;&gt;=1.2.*&quot;</span><span class="p">,</span>
</span><span class='line'>    <span class="nt">&quot;bootstrap&quot;</span><span class="p">:</span> <span class="s2">&quot;&gt;=3.2.*&quot;</span><span class="p">,</span>
</span><span class='line'>    <span class="nt">&quot;less.js&quot;</span><span class="p">:</span> <span class="s2">&quot;&gt;=1.7.*&quot;</span><span class="p">,</span>
</span><span class='line'>    <span class="nt">&quot;fontawesome&quot;</span><span class="p">:</span> <span class="s2">&quot;&gt;=4.2.x&quot;</span><span class="p">,</span>
</span><span class='line'>    <span class="nt">&quot;angular-xeditable&quot;</span><span class="p">:</span> <span class="s2">&quot;&gt;=0.1.x&quot;</span><span class="p">,</span>
</span><span class='line'>    <span class="nt">&quot;angular-mocks&quot;</span><span class="p">:</span> <span class="s2">&quot;&gt;=1.2.*&quot;</span>
</span><span class='line'>
</span><span class='line'><span class="p">}</span><span class="err">,</span>
</span><span class='line'><span class="s2">&quot;devDependencies&quot;</span><span class="err">:</span> <span class="p">{</span>
</span><span class='line'>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>Insert the list of dependencies Bower has to inject into <code>index.html</code> and remove them from <code>package.json</code>. Now frontend dependencies are managed and injected by <em>Bower</em> and not anymore by <em>npm</em></p>

<figure class='code'><figcaption><span>app/views/index.html</span> — <a href='https://github.com/blackat/popcorn-time-express-angular-mongodb-grunt/blob/master/app/views/index.html'>Link</a></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
</pre></td><td class='code'><pre><code class='html'><span class='line'><span class="cp">&lt;!DOCTYPE html&gt;</span>
</span><span class='line'><span class="nt">&lt;html</span> <span class="na">lang=</span><span class="s">&quot;en&quot;</span> <span class="na">ng-app=</span><span class="s">&quot;movieApp&quot;</span><span class="nt">&gt;</span>
</span><span class='line'><span class="nt">&lt;head&gt;</span>
</span><span class='line'>    <span class="nt">&lt;meta</span> <span class="na">charset=</span><span class="s">&quot;utf-8&quot;</span><span class="nt">&gt;</span>
</span><span class='line'>    <span class="nt">&lt;meta</span> <span class="na">name=</span><span class="s">&quot;viewport&quot;</span> <span class="na">content=</span><span class="s">&quot;width=device-width, initial-scale=1&quot;</span><span class="nt">&gt;</span>
</span><span class='line'>    <span class="nt">&lt;title&gt;</span>Movie page<span class="nt">&lt;/title&gt;</span>
</span><span class='line'>    <span class="c">&lt;!-- bower:css --&gt;</span>
</span><span class='line'>    <span class="c">&lt;!-- endbower --&gt;</span>
</span><span class='line'>    <span class="nt">&lt;link</span> <span class="na">href=</span><span class="s">&quot;/styles/style.less&quot;</span> <span class="na">rel=</span><span class="s">&quot;stylesheet/less&quot;</span><span class="nt">&gt;</span>
</span><span class='line'><span class="nt">&lt;/head&gt;</span>
</span><span class='line'><span class="nt">&lt;body</span> <span class="na">ng-controller=</span><span class="s">&quot;MainController&quot;</span><span class="nt">&gt;</span>
</span><span class='line'>...
</span><span class='line'><span class="nt">&lt;/body&gt;</span>
</span><span class='line'><span class="c">&lt;!-- bower:js --&gt;</span>
</span><span class='line'><span class="c">&lt;!-- endbower --&gt;</span>
</span><span class='line'><span class="nt">&lt;script </span><span class="na">src=</span><span class="s">&quot;scripts/services/services.js&quot;</span><span class="nt">&gt;&lt;/script&gt;</span>
</span><span class='line'><span class="nt">&lt;script </span><span class="na">src=</span><span class="s">&quot;scripts/controllers/controllers.js&quot;</span><span class="nt">&gt;&lt;/script&gt;</span>
</span><span class='line'><span class="nt">&lt;/html&gt;</span>
</span></code></pre></td></tr></table></div></figure>


<p>Specify in <code>index.html</code> where <em>Bower</em> should insert css and javascript dependencies that have been specified in <code>bower.json</code>.</p>

<p>Once done run</p>

<ul>
<li><code>bower install</code> to download <em>Bower</em> components;</li>
<li><code>grunt serve</code> to run all the defined tasks and have the server up and running.</li>
</ul>


<p> Just to test the injection task run <code>grunt wiredep</code> and check that dependencies have been added to the <code>index.html</code> page as follows:</p>

<figure class='code'><figcaption><span>app/views/index.html</span> — <a href='https://github.com/blackat/popcorn-time-express-angular-mongodb-grunt/blob/master/app/views/index.html'>Link</a></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
<span class='line-number'>26</span>
<span class='line-number'>27</span>
<span class='line-number'>28</span>
</pre></td><td class='code'><pre><code class='html'><span class='line'><span class="cp">&lt;!DOCTYPE html&gt;</span>
</span><span class='line'><span class="nt">&lt;html</span> <span class="na">lang=</span><span class="s">&quot;en&quot;</span> <span class="na">ng-app=</span><span class="s">&quot;movieApp&quot;</span><span class="nt">&gt;</span>
</span><span class='line'><span class="nt">&lt;head&gt;</span>
</span><span class='line'>     <span class="nt">&lt;meta</span> <span class="na">charset=</span><span class="s">&quot;utf-8&quot;</span><span class="nt">&gt;</span>
</span><span class='line'>     <span class="nt">&lt;meta</span> <span class="na">name=</span><span class="s">&quot;viewport&quot;</span> <span class="na">content=</span><span class="s">&quot;width=device-width, initial-scale=1&quot;</span><span class="nt">&gt;</span>
</span><span class='line'>     <span class="nt">&lt;title&gt;</span>Movie page<span class="nt">&lt;/title&gt;</span>
</span><span class='line'>     <span class="c">&lt;!-- bower:css --&gt;</span>
</span><span class='line'>     <span class="nt">&lt;link</span> <span class="na">rel=</span><span class="s">&quot;stylesheet&quot;</span> <span class="na">href=</span><span class="s">&quot;../bower_components/bootstrap/dist/css/bootstrap.css&quot;</span> <span class="nt">/&gt;</span>
</span><span class='line'>     <span class="nt">&lt;link</span> <span class="na">rel=</span><span class="s">&quot;stylesheet&quot;</span> <span class="na">href=</span><span class="s">&quot;../bower_components/fontawesome/css/font-awesome.css&quot;</span> <span class="nt">/&gt;</span>
</span><span class='line'>     <span class="nt">&lt;link</span> <span class="na">rel=</span><span class="s">&quot;stylesheet&quot;</span> <span class="na">href=</span><span class="s">&quot;../bower_components/angular-xeditable/dist/css/xeditable.css&quot;</span> <span class="nt">/&gt;</span>
</span><span class='line'>     <span class="c">&lt;!-- endbower --&gt;</span>
</span><span class='line'>     <span class="nt">&lt;link</span> <span class="na">href=</span><span class="s">&quot;/styles/style.less&quot;</span> <span class="na">rel=</span><span class="s">&quot;stylesheet/less&quot;</span><span class="nt">&gt;</span>
</span><span class='line'><span class="nt">&lt;/head&gt;</span>
</span><span class='line'><span class="nt">&lt;body</span> <span class="na">ng-controller=</span><span class="s">&quot;MainController&quot;</span><span class="nt">&gt;</span>
</span><span class='line'> ...
</span><span class='line'><span class="nt">&lt;/body&gt;</span>
</span><span class='line'><span class="c">&lt;!-- bower:js --&gt;</span>
</span><span class='line'><span class="nt">&lt;script </span><span class="na">src=</span><span class="s">&quot;../bower_components/jquery/dist/jquery.js&quot;</span><span class="nt">&gt;&lt;/script&gt;</span>
</span><span class='line'><span class="nt">&lt;script </span><span class="na">src=</span><span class="s">&quot;../bower_components/angular/angular.js&quot;</span><span class="nt">&gt;&lt;/script&gt;</span>
</span><span class='line'><span class="nt">&lt;script </span><span class="na">src=</span><span class="s">&quot;../bower_components/angular-resource/angular-resource.js&quot;</span><span class="nt">&gt;&lt;/script&gt;</span>
</span><span class='line'><span class="nt">&lt;script </span><span class="na">src=</span><span class="s">&quot;../bower_components/angular-route/angular-route.js&quot;</span><span class="nt">&gt;&lt;/script&gt;</span>
</span><span class='line'><span class="nt">&lt;script </span><span class="na">src=</span><span class="s">&quot;../bower_components/less.js/dist/less-1.7.5.js&quot;</span><span class="nt">&gt;&lt;/script&gt;</span>
</span><span class='line'><span class="nt">&lt;script </span><span class="na">src=</span><span class="s">&quot;../bower_components/angular-xeditable/dist/js/xeditable.js&quot;</span><span class="nt">&gt;&lt;/script&gt;</span>
</span><span class='line'><span class="nt">&lt;script </span><span class="na">src=</span><span class="s">&quot;../bower_components/angular-mocks/angular-mocks.js&quot;</span><span class="nt">&gt;&lt;/script&gt;</span>
</span><span class='line'><span class="c">&lt;!-- endbower --&gt;</span>
</span><span class='line'><span class="nt">&lt;script </span><span class="na">src=</span><span class="s">&quot;scripts/services/services.js&quot;</span><span class="nt">&gt;&lt;/script&gt;</span>
</span><span class='line'><span class="nt">&lt;script </span><span class="na">src=</span><span class="s">&quot;scripts/controllers/controllers.js&quot;</span><span class="nt">&gt;&lt;/script&gt;</span>
</span><span class='line'><span class="nt">&lt;/html&gt;</span>
</span></code></pre></td></tr></table></div></figure>


<h2>2. MongoDB</h2>

<h3>2.1 Model</h3>

<p>As first thing I want to define the object model should be persisted, retrieved and finally show off in the client user interface. So in &lsquo;../lib/models&rsquo; define</p>

<figure class='code'><figcaption><span>/lib/models/product.js</span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
</pre></td><td class='code'><pre><code class='javascript'><span class='line'><span class="s1">&#39;use strict&#39;</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'><span class="kd">var</span> <span class="nx">mongoose</span> <span class="o">=</span> <span class="nx">require</span><span class="p">(</span><span class="s1">&#39;mongoose&#39;</span><span class="p">),</span>
</span><span class='line'>    <span class="nx">Schema</span>   <span class="o">=</span> <span class="nx">mongoose</span><span class="p">.</span><span class="nx">Schema</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'><span class="kd">var</span> <span class="nx">ProductSchema</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">Schema</span><span class="p">({</span>
</span><span class='line'>    <span class="nx">name</span><span class="o">:</span> <span class="nb">String</span><span class="p">,</span>
</span><span class='line'>    <span class="nx">description</span><span class="o">:</span> <span class="nb">String</span>
</span><span class='line'>    <span class="p">});</span>
</span><span class='line'>
</span><span class='line'><span class="nx">mongoose</span><span class="p">.</span><span class="nx">model</span><span class="p">(</span><span class="s1">&#39;Product&#39;</span><span class="p">,</span> <span class="nx">ProductSchema</span><span class="p">);</span>
</span></code></pre></td></tr></table></div></figure>


<p>I have decided to use <a href="http://mongoosejs.com/" title="Mongoose home page">mongoose</a> in order to reduce boilerplate code for validation, read/write operation and so on.</p>

<blockquote><p>With Mongoose, everything is derived from a Schema. Each <a href="http://mongoosejs.com/docs/guide.html" title="Mongoose Schemas">schema</a> maps to a MongoDB collection and defines the shape of the documents within that collection.</p></blockquote>

<p>I have defined a very simple schema for a product with only two fields <code>name</code> and <code>description</code>.</p>

<blockquote><p>Models are fancy constructors compiled from our Schema definitions.</p></blockquote>

<h4>Routes</h4>

<p>Once the user has required an action on a resource it has to be served according to its name and the <code>HTTP verb</code>. Thus create an instance of <a href="http://expressjs.com/4x/api.html#app.route" title="express route api">route</a> with a specific name and then manage all the <code>HTTP verbs</code> avoiding duplicates in names.</p>

<figure class='code'><figcaption><span>/lib/routes.js</span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
</pre></td><td class='code'><pre><code class='javascript'><span class='line'><span class="s1">&#39;use strict&#39;</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'><span class="kd">var</span> <span class="nx">products</span> <span class="o">=</span> <span class="nx">require</span><span class="p">(</span><span class="s1">&#39;./controllers/products&#39;</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'><span class="nx">module</span><span class="p">.</span><span class="nx">exports</span> <span class="o">=</span> <span class="kd">function</span><span class="p">(</span><span class="nx">app</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="nx">app</span><span class="p">.</span><span class="nx">route</span><span class="p">(</span><span class="s1">&#39;api/products&#39;</span><span class="p">).</span><span class="nx">get</span><span class="p">(</span><span class="nx">products</span><span class="p">.</span><span class="nx">products</span><span class="p">);</span>
</span><span class='line'><span class="p">};</span>
</span></code></pre></td></tr></table></div></figure>


<h4>Controller</h4>

<p>Once done the object should be retrieved from the data source, create a new module file in &lsquo;../lib/controllers&rsquo;:</p>

<figure class='code'><figcaption><span>/lib/controllers/products.js</span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
</pre></td><td class='code'><pre><code class='javascript'><span class='line'><span class="s1">&#39;use strict&#39;</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'><span class="kd">var</span> <span class="nx">mongoose</span> <span class="o">=</span> <span class="nx">require</span><span class="p">(</span><span class="s1">&#39;mongoose&#39;</span><span class="p">),</span>
</span><span class='line'>    <span class="nx">Product</span> <span class="o">=</span> <span class="nx">mongoose</span><span class="p">.</span><span class="nx">model</span><span class="p">(</span><span class="s1">&#39;Product&#39;</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'><span class="nx">exports</span><span class="p">.</span><span class="nx">products</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">req</span><span class="p">,</span> <span class="nx">res</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>    <span class="k">return</span> <span class="nx">Product</span><span class="p">.</span><span class="nx">find</span><span class="p">(</span><span class="kd">function</span> <span class="p">(</span><span class="nx">err</span><span class="p">,</span> <span class="nx">prods</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>        <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="nx">err</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>            <span class="k">return</span> <span class="nx">res</span><span class="p">.</span><span class="nx">json</span><span class="p">(</span><span class="nx">prods</span><span class="p">);</span>
</span><span class='line'>        <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
</span><span class='line'>            <span class="k">return</span> <span class="nx">res</span><span class="p">.</span><span class="nx">send</span><span class="p">(</span><span class="nx">err</span><span class="p">);</span>
</span><span class='line'>        <span class="p">}</span>
</span><span class='line'>    <span class="p">});</span>
</span><span class='line'><span class="p">};</span>
</span></code></pre></td></tr></table></div></figure>


<p>In order to retrieve all the product documents stored in the data source, use static method <code>find</code>. Documents are instances of the model.</p>

<p>The module <code>products.js</code> exports the function <code>products()</code> adding it to the <code>exports</code> object. The function will be added to the root of the module.</p>

<h4>RESTful Backend</h4>

<p>In order to better interact with the frontend, a RESTful backend has to be provided by means of <em>REST endpoints</em> as follows:</p>

<table>
<thead>
<tr>
<th>Url            </th>
<th> HTTP Verb </th>
<th> POST Body   </th>
<th> Result</th>
</tr>
</thead>
<tbody>
<tr>
<td>api/movies     </td>
<td> GET       </td>
<td> empty       </td>
<td> return all the movies    </td>
</tr>
<tr>
<td>api/movies     </td>
<td> POST      </td>
<td> JSON String </td>
<td> create a new movie       </td>
</tr>
<tr>
<td>api/movies/:id </td>
<td> GET       </td>
<td> empty       </td>
<td> return a single movie    </td>
</tr>
<tr>
<td>api/movies/:id </td>
<td> PUT       </td>
<td> JSON String </td>
<td> update an existing movie </td>
</tr>
<tr>
<td>api/movies/:id </td>
<td> DELETE    </td>
<td> empty       </td>
<td> delete an existing entry </td>
</tr>
</tbody>
</table>


<h2>3. Morgan the Logger</h2>

<h2>4. Angular</h2>

<p>A nice way to implement <em>CRUD operations</em> in <a href="https://angularjs.org/">Angular</a> is using <code>$resource</code> factory which helps to interact with a standard <em>REST endpoints</em>. In <code>bower.json</code> the module <code>angular-resource</code> is already present, then it will be injected into &lsquo;index.html&rsquo; by <a href="bower.io" title="Bower homepage">Bower</a>.</p>

<h3>4.1 Consuming a RESTful service</h3>

<figure class='code'><figcaption><span>/app/scripts/services/movieServices.js</span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
</pre></td><td class='code'><pre><code class='javascript'><span class='line'><span class="s1">&#39;use strict&#39;</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'><span class="kd">var</span>  <span class="nx">movieServices</span> <span class="o">=</span> <span class="nx">angular</span><span class="p">.</span><span class="nx">module</span><span class="p">(</span><span class="s1">&#39;movieApp.movieServices&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;ngResource&#39;</span><span class="p">]);</span>
</span><span class='line'>
</span><span class='line'><span class="nx">movieServices</span><span class="p">.</span><span class="nx">factory</span><span class="p">(</span><span class="s1">&#39;Movie&#39;</span><span class="p">,</span> <span class="kd">function</span><span class="p">(</span><span class="nx">$resource</span><span class="p">){</span>
</span><span class='line'>    <span class="k">return</span> <span class="nx">$resource</span><span class="p">(</span><span class="s1">&#39;movies/movies/:id&#39;</span><span class="p">,</span> <span class="p">{</span><span class="nx">id</span><span class="o">:</span><span class="s1">&#39;@_id&#39;</span><span class="p">});</span>
</span><span class='line'><span class="p">});</span>
</span></code></pre></td></tr></table></div></figure>


<p>Module <code>ngResource</code> needs to be installed and declared in order to use its <strong>service</strong> <code>$resource</code>. The returned resources has <strong>action methods</strong> providing higher-level behaviors than the low level <code>$http</code>.</p>

<p>According to Angular  <a href="https://docs.angularjs.org/api/ngResource/service/$resource">api</a> a parametrized URL has to be specified, it is the <em>full endpoint</em> address which covers all the URLs for basic CRUD operations.</p>

<pre><code>$resource(url, [paramDefaults], [actions], options);
</code></pre>

<p><code>:id</code> is the parameter and <code>{id:@_id}</code> is the name of the parameter in the <code>data</code> object provided when the method will be called, so it means extract the value of parameter <code>data._id</code> and assign it to <code>id</code> parameter.</p>

<p>The returned object has a <em>default set</em> of <strong>resource actions</strong> which can be extended with custom <code>actions</code>.</p>

<pre><code>{
    'get':    {method:'GET'},
    'save':   {method:'POST'},
    'query':  {method:'GET', isArray:true},
    'remove': {method:'DELETE'},
    'delete': {method:'DELETE'}
};
</code></pre>

<h2>5. Testing</h2>

<ul>
<li>unit test the RESTful api, user <a href="https://github.com/visionmedia/supertest">SuperTest</a></li>
<li>Jasmine</li>
<li>Karma</li>
<li>Mongodb? integration test?</li>
</ul>


<!-- Links -->

]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Fullstack Javascript Web Application Part 1]]></title>
    <link href="http://blackat.github.io/blog/2014/09/09/fullstack-javascript-web-application/"/>
    <updated>2014-09-09T22:13:06+02:00</updated>
    <id>http://blackat.github.io/blog/2014/09/09/fullstack-javascript-web-application</id>
    <content type="html"><![CDATA[<p>The web application will allow the user to manage a list of movies, show them, update them, store new ones and delete existing ones.</p>

<p><img class="center" src="http://blackat.github.io/images/posts/popcorn-time-screenshot.png"></p>

<p>This web application will help to show how to structure a full stack Javascript web application and which components are required to make it work.</p>

<p>The application will start simple and step by step components will be added such as the database, the testing framework, the task runner and the dependency management.</p>

<!-- more -->


<h2>1. Single Page Web Application Scaffolding</h2>

<p>As first step the web application will be composed by</p>

<ul>
<li>Node.js the web server</li>
<li>Express the web framework</li>
</ul>


<h3>1.1 Folder structure</h3>

<p>The starting point is the folder structure to organize resources and configuration files.</p>

<pre><code>├── app
│   └── views
│       └── index.html              # =&gt; single page of the web application
├── lib
│   ├── config
│   │   └── express.js      # =&gt; configuration file for expressjs framework
│   ├── controllers
│   │   └── index.js        # =&gt; controller to serve the starting page
│   └── routes.js           # =&gt; router to map REST request with controller
├── package.json            # =&gt; set of required nodeJs modules
└── server.js               # =&gt; boostrap of the server side
</code></pre>

<h3>1.2 Express Dependency</h3>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
</pre></td><td class='code'><pre><code class='json'><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="nt">&quot;name&quot;</span><span class="p">:</span> <span class="s2">&quot;popcorn-time-backend&quot;</span><span class="p">,</span>
</span><span class='line'>    <span class="nt">&quot;version&quot;</span><span class="p">:</span> <span class="s2">&quot;0.0.1&quot;</span><span class="p">,</span>
</span><span class='line'>    <span class="nt">&quot;dependencies&quot;</span><span class="p">:</span> <span class="p">{</span>
</span><span class='line'>        <span class="nt">&quot;express&quot;</span><span class="p">:</span> <span class="s2">&quot;4.0.x&quot;</span>
</span><span class='line'>    <span class="p">},</span>
</span><span class='line'>    <span class="nt">&quot;devDependencies&quot;</span><span class="p">:</span> <span class="p">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p><strong>Express</strong> is a web application framework for <strong>Node.js</strong> used to develop web application totally written in Javascript. The framework provides <em>high level methods</em> way to manage requests mapping a route with the designated controller able to provide data.</p>

<p>In the <code>package.json</code> file add the dependency on the web framework. This file is used by <code>npm</code> to store metadata of projects published as npm module and to easily installed them locally running the command <code>npm install</code>.</p>

<h3>1.3 Server Configuration</h3>

<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
</pre></td><td class='code'><pre><code class='javascript'><span class='line'><span class="kd">var</span> <span class="nx">express</span> <span class="o">=</span> <span class="nx">require</span><span class="p">(</span><span class="s1">&#39;express&#39;</span><span class="p">),</span>
</span><span class='line'>    <span class="nx">app</span> <span class="o">=</span> <span class="nx">express</span><span class="p">();</span>
</span><span class='line'>
</span><span class='line'><span class="nx">app</span><span class="p">.</span><span class="nx">get</span><span class="p">(</span><span class="s1">&#39;/&#39;</span><span class="p">,</span> <span class="kd">function</span><span class="p">(</span><span class="nx">req</span><span class="p">,</span> <span class="nx">res</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>    <span class="nx">res</span><span class="p">.</span><span class="nx">send</span><span class="p">(</span><span class="s2">&quot;Hello World&quot;</span><span class="p">)</span>
</span><span class='line'><span class="p">});</span>
</span><span class='line'>
</span><span class='line'><span class="kd">var</span> <span class="nx">server</span> <span class="o">=</span> <span class="nx">app</span><span class="p">.</span><span class="nx">listen</span><span class="p">(</span><span class="mi">9001</span><span class="p">,</span> <span class="kd">function</span><span class="p">()</span> <span class="p">{</span>
</span><span class='line'>    <span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="s1">&#39;Express server is listening on port %d&#39;</span><span class="p">,</span> <span class="nx">server</span><span class="p">.</span><span class="nx">address</span><span class="p">().</span><span class="nx">port</span><span class="p">);</span>
</span><span class='line'><span class="p">});</span>
</span></code></pre></td></tr></table></div></figure>


<p><strong>Express</strong> module is loaded by <code>require('express')</code> then a new application instance is created invoking <code>express()</code>.</p>

<p>Defined a route via</p>

<ul>
<li><code>app.VERB</code> method, where <code>VERB</code> stands for <code>HTTP VERB</code>. In the example <code>GET</code> is the verb;</li>
<li><code>/</code> the <code>URL</code> the route is mapped to;</li>
<li>a function implementation to manage request and response.</li>
</ul>


<p>Finally <em>bind</em> and <em>listen</em> for connection invoking method <code>app.listen()</code>.</p>

<h3>1.4 First Run of the Application</h3>

<p>Run <code>npm install</code> in the command line to locally install the declared dependencies. Once done type <code>node server.js</code>, open a browser and hit <code>http://localhost:9001</code>.</p>

<h3>1.5 Separate Express routes</h3>

<figure class='code'><figcaption><span>lib/routes.js</span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
</pre></td><td class='code'><pre><code class='javascript'><span class='line'><span class="nx">module</span><span class="p">.</span><span class="nx">exports</span> <span class="o">=</span> <span class="kd">function</span><span class="p">(</span><span class="nx">app</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="nx">app</span><span class="p">.</span><span class="nx">route</span><span class="p">(</span><span class="s1">&#39;/&#39;</span><span class="p">).</span><span class="nx">get</span><span class="p">(</span><span class="kd">function</span><span class="p">(</span><span class="nx">req</span><span class="p">,</span> <span class="nx">res</span><span class="p">,</span> <span class="nx">next</span><span class="p">){</span>
</span><span class='line'>        <span class="nx">res</span><span class="p">.</span><span class="nx">send</span><span class="p">(</span><span class="s1">&#39;Hello World&#39;</span><span class="p">);</span>
</span><span class='line'>    <span class="p">});</span>
</span><span class='line'><span class="p">};</span>
</span></code></pre></td></tr></table></div></figure>


<p>Express 4.0 has introduced the <code>app.route()</code> <a href="http://expressjs.com/4x/api.html#app.route" title="Express route method">method</a> which is the recommended approach to handle HTTP verbs. Routes are in a separated files which is loaded by <code>server.js</code> as follows.</p>

<figure class='code'><figcaption><span>server.js</span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
</pre></td><td class='code'><pre><code class='javascript'><span class='line'><span class="kd">var</span> <span class="nx">express</span> <span class="o">=</span> <span class="nx">require</span><span class="p">(</span><span class="s1">&#39;express&#39;</span><span class="p">),</span>
</span><span class='line'>    <span class="nx">app</span> <span class="o">=</span> <span class="nx">express</span><span class="p">();</span>
</span><span class='line'>
</span><span class='line'><span class="nx">require</span><span class="p">(</span><span class="s1">&#39;./lib/routes&#39;</span><span class="p">)(</span><span class="nx">app</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'><span class="kd">var</span> <span class="nx">server</span> <span class="o">=</span> <span class="nx">app</span><span class="p">.</span><span class="nx">listen</span><span class="p">(</span><span class="mi">9001</span><span class="p">,</span> <span class="kd">function</span><span class="p">(){</span>
</span><span class='line'>    <span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="s1">&#39;Express server is listening on port %d&#39;</span><span class="p">,</span> <span class="nx">server</span><span class="p">.</span><span class="nx">address</span><span class="p">().</span><span class="nx">port</span><span class="p">);</span>
</span><span class='line'><span class="p">});</span>
</span></code></pre></td></tr></table></div></figure>


<h3>1.6 Return index.html</h3>

<figure class='code'><figcaption><span>lib/routes.js</span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
</pre></td><td class='code'><pre><code class='javascript'><span class='line'><span class="kd">var</span> <span class="nx">index</span> <span class="o">=</span> <span class="nx">require</span><span class="p">(</span><span class="s1">&#39;./controllers&#39;</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'><span class="nx">module</span><span class="p">.</span><span class="nx">exports</span> <span class="o">=</span> <span class="kd">function</span><span class="p">(</span><span class="nx">app</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="nx">app</span><span class="p">.</span><span class="nx">route</span><span class="p">(</span><span class="s1">&#39;/&#39;</span><span class="p">).</span><span class="nx">get</span><span class="p">(</span><span class="nx">index</span><span class="p">.</span><span class="nx">index</span><span class="p">);</span>
</span><span class='line'><span class="p">};</span>
</span></code></pre></td></tr></table></div></figure>


<p>The <code>html</code> page will give the life to the single page web application. The function calls the <code>index</code> controller method called <code>index</code> which returns the page as follows:</p>

<figure class='code'><figcaption><span>lib/controllers/index.js</span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
</pre></td><td class='code'><pre><code class='javascript'><span class='line'><span class="nx">exports</span><span class="p">.</span><span class="nx">index</span> <span class="o">=</span> <span class="kd">function</span><span class="p">(</span><span class="nx">req</span><span class="p">,</span> <span class="nx">res</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>    <span class="nx">res</span><span class="p">.</span><span class="nx">render</span><span class="p">(</span><span class="s1">&#39;index&#39;</span><span class="p">);</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>Then the <code>html</code> page to be returned</p>

<figure class='code'><figcaption><span>app/index.html</span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
</pre></td><td class='code'><pre><code class='html'><span class='line'><span class="cp">&lt;!DOCTYPE html&gt;</span>
</span><span class='line'><span class="nt">&lt;html&gt;</span>
</span><span class='line'><span class="nt">&lt;head</span> <span class="na">lang=</span><span class="s">&quot;en&quot;</span><span class="nt">&gt;</span>
</span><span class='line'>    <span class="nt">&lt;meta</span> <span class="na">charset=</span><span class="s">&quot;UTF-8&quot;</span><span class="nt">&gt;</span>
</span><span class='line'>    <span class="nt">&lt;title&gt;</span>Popcorn Time<span class="nt">&lt;/title&gt;</span>
</span><span class='line'><span class="nt">&lt;/head&gt;</span>
</span><span class='line'><span class="nt">&lt;body&gt;</span>
</span><span class='line'>    <span class="nt">&lt;h1&gt;</span>Popcorn Time<span class="nt">&lt;/h1&gt;</span>
</span><span class='line'><span class="nt">&lt;/body&gt;</span>
</span><span class='line'><span class="nt">&lt;/html&gt;</span>
</span></code></pre></td></tr></table></div></figure>


<h3>1.7 Express Configuration and the Render Engine</h3>

<p>The <code>index.html</code> page cannot still be found by express. Configure the web framework to render and serve views from a given folder.</p>

<figure class='code'><figcaption><span>lib/config/express.js</span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
</pre></td><td class='code'><pre><code class='javascript'><span class='line'><span class="kd">var</span> <span class="nx">path</span> <span class="o">=</span> <span class="nx">require</span><span class="p">(</span><span class="s1">&#39;path&#39;</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'><span class="nx">module</span><span class="p">.</span><span class="nx">exports</span> <span class="o">=</span> <span class="kd">function</span><span class="p">(</span><span class="nx">app</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">var</span> <span class="nx">rootpath</span> <span class="o">=</span> <span class="nx">path</span><span class="p">.</span><span class="nx">normalize</span><span class="p">(</span><span class="nx">__dirname</span> <span class="o">+</span> <span class="s1">&#39;/../..&#39;</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="nx">app</span><span class="p">.</span><span class="nx">set</span><span class="p">(</span><span class="s1">&#39;views&#39;</span><span class="p">,</span> <span class="nx">rootpath</span> <span class="o">+</span> <span class="s1">&#39;/app/views&#39;</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="nx">app</span><span class="p">.</span><span class="nx">engine</span><span class="p">(</span><span class="s1">&#39;html&#39;</span><span class="p">,</span> <span class="nx">require</span><span class="p">(</span><span class="s1">&#39;ejs&#39;</span><span class="p">).</span><span class="nx">renderFile</span><span class="p">);</span>
</span><span class='line'>    <span class="nx">app</span><span class="p">.</span><span class="nx">set</span><span class="p">(</span><span class="s1">&#39;view engine&#39;</span><span class="p">,</span> <span class="s1">&#39;html&#39;</span><span class="p">);</span>
</span><span class='line'><span class="p">};</span>
</span></code></pre></td></tr></table></div></figure>


<p>Finally add <code>ejs</code> render engine for <code>html</code> page as a dependency</p>

<figure class='code'><figcaption><span>package.json</span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
</pre></td><td class='code'><pre><code class='json'><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="nt">&quot;name&quot;</span><span class="p">:</span> <span class="s2">&quot;popcorn-time-backend&quot;</span><span class="p">,</span>
</span><span class='line'>    <span class="nt">&quot;version&quot;</span><span class="p">:</span> <span class="s2">&quot;0.0.1&quot;</span><span class="p">,</span>
</span><span class='line'>    <span class="nt">&quot;dependencies&quot;</span><span class="p">:</span> <span class="p">{</span>
</span><span class='line'>        <span class="nt">&quot;express&quot;</span><span class="p">:</span> <span class="s2">&quot;4.0.x&quot;</span><span class="p">,</span>
</span><span class='line'>        <span class="nt">&quot;ejs&quot;</span><span class="p">:</span> <span class="s2">&quot;~0.8.4&quot;</span>
</span><span class='line'>    <span class="p">},</span>
</span><span class='line'>    <span class="nt">&quot;devDependencies&quot;</span><span class="p">:</span> <span class="p">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<h3>1.8 Update Server with Express Configuration</h3>

<p>Update the server requiring the express configuration</p>

<figure class='code'><figcaption><span>server.js</span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
</pre></td><td class='code'><pre><code class='javascript'><span class='line'><span class="kd">var</span> <span class="nx">express</span> <span class="o">=</span> <span class="nx">require</span><span class="p">(</span><span class="s1">&#39;express&#39;</span><span class="p">),</span>
</span><span class='line'>    <span class="nx">app</span> <span class="o">=</span> <span class="nx">express</span><span class="p">();</span>
</span><span class='line'>
</span><span class='line'><span class="nx">require</span><span class="p">(</span><span class="s1">&#39;./lib/routes&#39;</span><span class="p">)(</span><span class="nx">app</span><span class="p">);</span>
</span><span class='line'><span class="nx">require</span><span class="p">(</span><span class="s1">&#39;./lib/config/express&#39;</span><span class="p">)(</span><span class="nx">app</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'><span class="kd">var</span> <span class="nx">server</span> <span class="o">=</span> <span class="nx">app</span><span class="p">.</span><span class="nx">listen</span><span class="p">(</span><span class="mi">9001</span><span class="p">,</span> <span class="kd">function</span><span class="p">(){</span>
</span><span class='line'>    <span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="s1">&#39;Express server is listening on port %d&#39;</span><span class="p">,</span> <span class="nx">server</span><span class="p">.</span><span class="nx">address</span><span class="p">().</span><span class="nx">port</span><span class="p">);</span>
</span><span class='line'><span class="p">});</span>
</span></code></pre></td></tr></table></div></figure>


<p>then run <code>npm install</code>, <code>node server.js</code> and check the result in the browser.</p>

<h2>2 Web Application features and Look &amp; Feel</h2>

<p>In this second step some features and look &amp; feel will be added to the web application through</p>

<ul>
<li>Angular the ui framework</li>
<li>Bootstrap the css framework</li>
</ul>


<h3>2.1 Folder Structure</h3>

<pre><code>├── app
│   ├── favicon.ico
│   ├── fonts
│   │   └── Lobster_1.3.otf
│   ├── images
│   │   ├── play.png
│   │   └── popcorn.png
│   ├── package.json                # =&gt; dependency modules of the frontend
│   ├── scripts
│   │   ├── controllers
│   │   │   ├── controllers.js      # =&gt; angular controllers
│   │   │   └── xeditable.min.js    # =&gt; angular xeditable
│   │   ├── directives
│   │   └── services
│   │       └── services.js         # =&gt; angular REST services
│   ├── styles
│   │   ├── style.less              # =&gt; less style sheet
│   │   └── xeditable.css
│   └── views
│       └── index.html              # =&gt; single page of the web application
├── lib
│   ├── config
│   │   └── express.js
│   ├── controllers
│   │   └── index.js
│   └── routes.js
├── package.json
├── popcorn-time-express-angular.iml
└── server.js
</code></pre>

<p>Some folders have been added in order to better organize the frontend code, images, styles and so on.</p>

<h3>2.2 Dependencies Configuration</h3>

<figure class='code'><figcaption><span>app/package.json</span> — <a href='https://github.com/blackat/popcorn-time-express-angular/blob/master/app/package.json'>Link</a></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
</pre></td><td class='code'><pre><code class='json'><span class='line'><span class="p">{</span>
</span><span class='line'>    <span class="nt">&quot;name&quot;</span><span class="p">:</span> <span class="s2">&quot;popcorn-time-frontend&quot;</span><span class="p">,</span>
</span><span class='line'>    <span class="nt">&quot;version&quot;</span><span class="p">:</span> <span class="s2">&quot;1.0.0&quot;</span><span class="p">,</span>
</span><span class='line'>    <span class="nt">&quot;dependencies&quot;</span><span class="p">:</span> <span class="p">{</span>
</span><span class='line'>        <span class="nt">&quot;angular&quot;</span><span class="p">:</span> <span class="s2">&quot;1.2.x&quot;</span><span class="p">,</span>
</span><span class='line'>        <span class="nt">&quot;angular-mocks&quot;</span><span class="p">:</span> <span class="s2">&quot;~1.2.x&quot;</span><span class="p">,</span>
</span><span class='line'>        <span class="nt">&quot;angular-route&quot;</span><span class="p">:</span> <span class="s2">&quot;~1.2.x&quot;</span><span class="p">,</span>
</span><span class='line'>        <span class="nt">&quot;angular-resource&quot;</span><span class="p">:</span> <span class="s2">&quot;0.1.0&quot;</span><span class="p">,</span>
</span><span class='line'>        <span class="nt">&quot;bootstrap&quot;</span><span class="p">:</span> <span class="s2">&quot;3.2.x&quot;</span><span class="p">,</span>
</span><span class='line'>        <span class="nt">&quot;less&quot;</span><span class="p">:</span> <span class="s2">&quot;1.7.x&quot;</span>
</span><span class='line'>    <span class="p">},</span>
</span><span class='line'>    <span class="nt">&quot;devDependencies&quot;</span><span class="p">:</span> <span class="p">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="p">}</span>
</span><span class='line'><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>The frontend has a separated file to configure the dependencies from the backend one. <em>Angular</em> and <em>Bootstrap</em> dependencies have been added along with <em>Less</em> in order to resolve <code>*.less</code> style sheet files on the fly.</p>

<h3>2.3 Serve Static Resources</h3>

<figure class='code'><figcaption><span>lib/config/express.js</span> — <a href='https://github.com/blackat/popcorn-time-express-angular/blob/master/lib/config/express.js'>Link</a></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
</pre></td><td class='code'><pre><code class='javascript'><span class='line'><span class="s1">&#39;use strict&#39;</span><span class="p">;</span>
</span><span class='line'>
</span><span class='line'><span class="kd">var</span> <span class="nx">path</span> <span class="o">=</span> <span class="nx">require</span><span class="p">(</span><span class="s1">&#39;path&#39;</span><span class="p">),</span>
</span><span class='line'>    <span class="nx">express</span> <span class="o">=</span> <span class="nx">require</span><span class="p">(</span><span class="s1">&#39;express&#39;</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'><span class="nx">module</span><span class="p">.</span><span class="nx">exports</span> <span class="o">=</span> <span class="kd">function</span><span class="p">(</span><span class="nx">app</span><span class="p">)</span> <span class="p">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">var</span> <span class="nx">rootpath</span> <span class="o">=</span> <span class="nx">path</span><span class="p">.</span><span class="nx">normalize</span><span class="p">(</span><span class="nx">__dirname</span> <span class="o">+</span> <span class="s1">&#39;/../..&#39;</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="nx">app</span><span class="p">.</span><span class="nx">use</span><span class="p">(</span><span class="nx">express</span><span class="p">.</span><span class="kr">static</span><span class="p">(</span><span class="s1">&#39;app&#39;</span><span class="p">));</span>
</span><span class='line'>    <span class="nx">app</span><span class="p">.</span><span class="nx">set</span><span class="p">(</span><span class="s1">&#39;views&#39;</span><span class="p">,</span> <span class="nx">rootpath</span> <span class="o">+</span> <span class="s1">&#39;/app/views&#39;</span><span class="p">);</span>
</span><span class='line'>
</span><span class='line'>    <span class="nx">app</span><span class="p">.</span><span class="nx">engine</span><span class="p">(</span><span class="s1">&#39;html&#39;</span><span class="p">,</span> <span class="nx">require</span><span class="p">(</span><span class="s1">&#39;ejs&#39;</span><span class="p">).</span><span class="nx">renderFile</span><span class="p">);</span>
</span><span class='line'>    <span class="nx">app</span><span class="p">.</span><span class="nx">set</span><span class="p">(</span><span class="s1">&#39;view engine&#39;</span><span class="p">,</span> <span class="s1">&#39;html&#39;</span><span class="p">);</span>
</span><span class='line'><span class="p">};</span>
</span></code></pre></td></tr></table></div></figure>


<p>Let&rsquo;s add the configuration for the static resources path so they can be referenced from the <code>index.html</code> page.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Synchronizers]]></title>
    <link href="http://blackat.github.io/blog/2013/05/31/synchronizers/"/>
    <updated>2013-05-31T05:54:00+02:00</updated>
    <id>http://blackat.github.io/blog/2013/05/31/synchronizers</id>
    <content type="html"><![CDATA[<p>Synchonizers are high-level abstraction in order to synchonize activities of two or more threads.</p>

<p>The group of synchronizers includes:</p>

<ul>
<li><strong><a href="#semaphore">Semaphore.</a></strong> Controls access to one ore more shared resources.</li>
<li><strong><a href="#phaser">Phaser.</a></strong> Used to support a synchronization barrier.</li>
<li><strong><a href="#countdownlatch">CountDownLatch.</a></strong> Allows threads to wait for a countdown to complete.</li>
<li><strong><a href="#exchanger">Exchanger.</a></strong> Supports exchanging data between two threads.</li>
<li><strong><a href="#cyclicbarrier">CyclicBarrier.</a></strong> Enables threads to wait at a predefined execution point.</li>
</ul>


<!-- more -->


<h2>Modeling Approach</h2>

<p>In the following examples a scenario is taken from reality modeled using threads and synchonizers. In general, each participant to the real world scenario is modeled as a thread and all of them share a resource.</p>

<p>The common and recurring pattern is: a group of threads and their coordination to access a shared resource or a limited and shared number of resources. A resource could be seen as the <em>synchronizer</em>.</p>

<p>It is possible to describe entities in the following way:</p>

<ul>
<li><em>synchonizer or resource</em> is something someone want to have access to, or is waiting for,</li>
<li><em>thread</em> is a participant trying to use, conquer, access a resource.</li>
</ul>


<p>In all the scenario a <em>challenge</em> can be identified and can help to understand how to model the piece of the reality by using threads and synchronizers.</p>

<h2><a id="semaphore">Semaphore</a></h2>

<h3>Scenario</h3>

<p>It is the classical one where many people want to get cash from a small number of cash machines.</p>

<p>Basically each person is modeled as a thread because is the participant to a challenge to use the cash machine which is the shared resource. Being the shared resource implies that the cash machine is the synchronizer, the <em>semaphore</em>.</p>

<h3>Code</h3>

<p>To model a person as a thread just create a class extending <code>java.lang.Thread</code> class or implementing <code>java.lang.Runnable</code> interface.</p>

<p>The use of the semaphore is extremely simple, a thread tries to <em>acquire</em> the control or <em>lock</em> on the object calling <code>cashMachine.acquire()</code>. The thread starts in <code>runnable</code> state and then is put in <code>wait</code> state waiting to acquire the semaphore.</p>

<p>Once the semaphore will be acquire, the thread will simulate the cash withdrawal step and then it will release the resource so other people can use the cash machine.</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
<span class='line-number'>26</span>
<span class='line-number'>27</span>
<span class='line-number'>28</span>
<span class='line-number'>29</span>
<span class='line-number'>30</span>
<span class='line-number'>31</span>
<span class='line-number'>32</span>
<span class='line-number'>33</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kn">package</span> <span class="n">com</span><span class="o">.</span><span class="na">contrastofbeauty</span><span class="o">.</span><span class="na">tuts</span><span class="o">.</span><span class="na">concurrency</span><span class="o">.</span><span class="na">synchronizers</span><span class="o">.</span><span class="na">semaphore</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'><span class="kn">import</span> <span class="nn">java.util.concurrent.Semaphore</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">Person</span> <span class="kd">implements</span> <span class="n">Runnable</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">public</span> <span class="kd">static</span> <span class="kd">final</span> <span class="kt">int</span> <span class="n">WITHDRAWAL_TIME</span> <span class="o">=</span> <span class="mi">1000</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">private</span> <span class="n">Semaphore</span> <span class="n">cashMachine</span><span class="o">;</span>
</span><span class='line'>    <span class="kd">private</span> <span class="n">String</span> <span class="n">name</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">public</span> <span class="nf">Person</span><span class="o">(</span><span class="kd">final</span> <span class="n">Semaphore</span> <span class="n">machine</span><span class="o">,</span> <span class="kd">final</span> <span class="n">String</span> <span class="n">personName</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>        <span class="n">cashMachine</span> <span class="o">=</span> <span class="n">machine</span><span class="o">;</span>
</span><span class='line'>        <span class="n">name</span> <span class="o">=</span> <span class="n">personName</span><span class="o">;</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="nd">@Override</span>
</span><span class='line'>    <span class="kd">public</span> <span class="kd">final</span> <span class="kt">void</span> <span class="nf">run</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>        <span class="n">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="n">Thread</span><span class="o">.</span><span class="na">currentThread</span><span class="o">().</span><span class="na">getName</span><span class="o">()</span> <span class="o">+</span> <span class="s">&quot; is waiting for the cash machine.&quot;</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>        <span class="k">try</span> <span class="o">{</span>
</span><span class='line'>            <span class="n">cashMachine</span><span class="o">.</span><span class="na">acquire</span><span class="o">();</span>
</span><span class='line'>            <span class="n">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="n">Thread</span><span class="o">.</span><span class="na">currentThread</span><span class="o">().</span><span class="na">getName</span><span class="o">()</span> <span class="o">+</span> <span class="s">&quot; is using the cash machine.&quot;</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>            <span class="n">Thread</span><span class="o">.</span><span class="na">sleep</span><span class="o">(</span><span class="n">WITHDRAWAL_TIME</span><span class="o">);</span> <span class="c1">// simulate the user withdrawal</span>
</span><span class='line'>
</span><span class='line'>            <span class="n">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="n">Thread</span><span class="o">.</span><span class="na">currentThread</span><span class="o">().</span><span class="na">getName</span><span class="o">()</span> <span class="o">+</span> <span class="s">&quot; has done with the cash machine.&quot;</span><span class="o">);</span>
</span><span class='line'>            <span class="n">cashMachine</span><span class="o">.</span><span class="na">release</span><span class="o">();</span>
</span><span class='line'>        <span class="o">}</span> <span class="k">catch</span> <span class="o">(</span><span class="n">InterruptedException</span> <span class="n">e</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>            <span class="n">System</span><span class="o">.</span><span class="na">err</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="n">e</span><span class="o">);</span>
</span><span class='line'>        <span class="o">}</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>A <code>java.util.concurrent.Semaphore</code> instance is used to simulate three cash machines (the counter starts from 0). Six people/threads are created to model six possible concurrent access to the three resources.</p>

<p>The semaphore models the access to a pool of cash machines or resources and it is the mean to get access to.</p>

<p><strong>Remember</strong> to start each thread invoking <code>start()</code> method over each new created thread.</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kn">package</span> <span class="n">com</span><span class="o">.</span><span class="na">contrastofbeauty</span><span class="o">.</span><span class="na">tuts</span><span class="o">.</span><span class="na">concurrency</span><span class="o">.</span><span class="na">synchronizers</span><span class="o">.</span><span class="na">semaphore</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'><span class="kn">import</span> <span class="nn">java.util.concurrent.Semaphore</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'><span class="kd">public</span> <span class="kd">final</span> <span class="kd">class</span> <span class="nc">ClientExecutor</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">private</span> <span class="nf">ClientExecutor</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">public</span> <span class="kd">static</span> <span class="kt">void</span> <span class="nf">main</span><span class="o">(</span><span class="kd">final</span> <span class="n">String</span><span class="o">[]</span> <span class="n">args</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>        <span class="c1">// semaphore control the access to the 3 available cash machines</span>
</span><span class='line'>        <span class="n">Semaphore</span> <span class="n">cashmachines</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">Semaphore</span><span class="o">(</span><span class="mi">2</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>        <span class="k">new</span> <span class="nf">Thread</span><span class="o">(</span><span class="k">new</span> <span class="nf">Person</span><span class="o">(</span><span class="n">cashmachines</span><span class="o">,</span> <span class="s">&quot;Einstein&quot;</span><span class="o">),</span> <span class="s">&quot;Einstein&quot;</span><span class="o">).</span><span class="na">start</span><span class="o">();</span>
</span><span class='line'>        <span class="k">new</span> <span class="nf">Thread</span><span class="o">(</span><span class="k">new</span> <span class="nf">Person</span><span class="o">(</span><span class="n">cashmachines</span><span class="o">,</span> <span class="s">&quot;Fermi&quot;</span><span class="o">),</span> <span class="s">&quot;Fermi&quot;</span><span class="o">).</span><span class="na">start</span><span class="o">();</span>
</span><span class='line'>        <span class="k">new</span> <span class="nf">Thread</span><span class="o">(</span><span class="k">new</span> <span class="nf">Person</span><span class="o">(</span><span class="n">cashmachines</span><span class="o">,</span> <span class="s">&quot;oppenheimer&quot;</span><span class="o">),</span> <span class="s">&quot;oppenheimer&quot;</span><span class="o">).</span><span class="na">start</span><span class="o">();</span>
</span><span class='line'>        <span class="k">new</span> <span class="nf">Thread</span><span class="o">(</span><span class="k">new</span> <span class="nf">Person</span><span class="o">(</span><span class="n">cashmachines</span><span class="o">,</span> <span class="s">&quot;Majorana&quot;</span><span class="o">),</span> <span class="s">&quot;Majorana&quot;</span><span class="o">).</span><span class="na">start</span><span class="o">();</span>
</span><span class='line'>        <span class="k">new</span> <span class="nf">Thread</span><span class="o">(</span><span class="k">new</span> <span class="nf">Person</span><span class="o">(</span><span class="n">cashmachines</span><span class="o">,</span> <span class="s">&quot;Turing&quot;</span><span class="o">),</span> <span class="s">&quot;Turing&quot;</span><span class="o">).</span><span class="na">start</span><span class="o">();</span>
</span><span class='line'>        <span class="k">new</span> <span class="nf">Thread</span><span class="o">(</span><span class="k">new</span> <span class="nf">Person</span><span class="o">(</span><span class="n">cashmachines</span><span class="o">,</span> <span class="s">&quot;von Neumann&quot;</span><span class="o">),</span> <span class="s">&quot;von Neumann&quot;</span><span class="o">).</span><span class="na">start</span><span class="o">();</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<h2><a id="phaser">Phaser</a></h2>

<h3>Scenario</h3>

<h3>Code</h3>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kn">package</span> <span class="n">com</span><span class="o">.</span><span class="na">contrastofbeauty</span><span class="o">.</span><span class="na">tuts</span><span class="o">.</span><span class="na">concurrency</span><span class="o">.</span><span class="na">synchronizers</span><span class="o">.</span><span class="na">phaser</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'><span class="kn">import</span> <span class="nn">java.util.concurrent.Phaser</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">AssemblerRobot</span> <span class="kd">implements</span> <span class="n">Runnable</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">private</span> <span class="n">Phaser</span> <span class="n">workPhaser</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">private</span> <span class="n">String</span> <span class="n">name</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">public</span> <span class="nf">AssemblerRobot</span><span class="o">(</span><span class="kd">final</span> <span class="n">Phaser</span> <span class="n">phaser</span><span class="o">,</span> <span class="kd">final</span> <span class="n">String</span> <span class="n">robotName</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>        <span class="n">workPhaser</span> <span class="o">=</span> <span class="n">phaser</span><span class="o">;</span>
</span><span class='line'>        <span class="n">name</span> <span class="o">=</span> <span class="n">robotName</span><span class="o">;</span>
</span><span class='line'>        <span class="c1">// the party register itself to synchronize</span>
</span><span class='line'>        <span class="n">workPhaser</span><span class="o">.</span><span class="na">register</span><span class="o">();</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="nd">@Override</span>
</span><span class='line'>    <span class="kd">public</span> <span class="kt">void</span> <span class="nf">run</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>        <span class="c1">//To change body of implemented methods use File | Settings | File Templates.</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>




<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kn">package</span> <span class="n">com</span><span class="o">.</span><span class="na">contrastofbeauty</span><span class="o">.</span><span class="na">tuts</span><span class="o">.</span><span class="na">concurrency</span><span class="o">.</span><span class="na">synchronizers</span><span class="o">.</span><span class="na">phaser</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'><span class="kn">import</span> <span class="nn">java.util.concurrent.Phaser</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'><span class="kd">public</span> <span class="kd">final</span> <span class="kd">class</span> <span class="nc">ClientExecutor</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">private</span> <span class="nf">ClientExecutor</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">public</span> <span class="kd">static</span> <span class="kt">void</span> <span class="nf">main</span><span class="o">(</span><span class="kd">final</span> <span class="n">String</span> <span class="n">args</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>        <span class="c1">// only one party is register, other parties can further register themselves</span>
</span><span class='line'>        <span class="n">Phaser</span> <span class="n">assembler</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">Phaser</span><span class="o">(</span><span class="mi">1</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>        <span class="k">new</span> <span class="nf">Thread</span><span class="o">(</span><span class="k">new</span> <span class="nf">AssemblerRobot</span><span class="o">(</span><span class="n">assembler</span><span class="o">,</span> <span class="s">&quot;External assembler&quot;</span><span class="o">)).</span><span class="na">start</span><span class="o">();</span>
</span><span class='line'>
</span><span class='line'>        <span class="k">new</span> <span class="nf">Thread</span><span class="o">(</span><span class="k">new</span> <span class="nf">AssemblerRobot</span><span class="o">(</span><span class="n">assembler</span><span class="o">,</span> <span class="s">&quot;Interior assembler&quot;</span><span class="o">)).</span><span class="na">start</span><span class="o">();</span>
</span><span class='line'>
</span><span class='line'>        <span class="k">new</span> <span class="nf">Thread</span><span class="o">(</span><span class="k">new</span> <span class="nf">AssemblerRobot</span><span class="o">(</span><span class="n">assembler</span><span class="o">,</span> <span class="s">&quot;Wheel assembler&quot;</span><span class="o">)).</span><span class="na">start</span><span class="o">();</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<h2><a id="countdownlatch">CountDownLatch</a></h2>

<h3>Scenario</h3>

<h3>Code</h3>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kn">package</span> <span class="n">com</span><span class="o">.</span><span class="na">contrastofbeauty</span><span class="o">.</span><span class="na">tuts</span><span class="o">.</span><span class="na">concurrency</span><span class="o">.</span><span class="na">synchronizers</span><span class="o">.</span><span class="na">countdownlatch</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'><span class="kn">import</span> <span class="nn">java.util.concurrent.CountDownLatch</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">Runner</span> <span class="kd">implements</span> <span class="n">Runnable</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">private</span> <span class="n">CountDownLatch</span> <span class="n">timer</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">public</span> <span class="nf">Runner</span><span class="o">(</span><span class="kd">final</span> <span class="n">CountDownLatch</span> <span class="n">counter</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>        <span class="n">timer</span> <span class="o">=</span> <span class="n">counter</span><span class="o">;</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="nd">@Override</span>
</span><span class='line'>    <span class="kd">public</span> <span class="kd">final</span> <span class="kt">void</span> <span class="nf">run</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>        <span class="n">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="n">Thread</span><span class="o">.</span><span class="na">currentThread</span><span class="o">().</span><span class="na">getName</span><span class="o">()</span> <span class="o">+</span> <span class="s">&quot; waiting to run.&quot;</span><span class="o">);</span>
</span><span class='line'>        <span class="k">try</span> <span class="o">{</span>
</span><span class='line'>            <span class="c1">// the thread waits for the timer to reach 0 and be released</span>
</span><span class='line'>            <span class="n">timer</span><span class="o">.</span><span class="na">await</span><span class="o">();</span>
</span><span class='line'>
</span><span class='line'>        <span class="o">}</span> <span class="k">catch</span> <span class="o">(</span><span class="n">InterruptedException</span> <span class="n">e</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>            <span class="n">System</span><span class="o">.</span><span class="na">err</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="n">e</span><span class="o">);</span>
</span><span class='line'>        <span class="o">}</span>
</span><span class='line'>        <span class="n">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="n">Thread</span><span class="o">.</span><span class="na">currentThread</span><span class="o">().</span><span class="na">getName</span><span class="o">()</span> <span class="o">+</span> <span class="s">&quot; started to run.&quot;</span><span class="o">);</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>




<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
<span class='line-number'>26</span>
<span class='line-number'>27</span>
<span class='line-number'>28</span>
<span class='line-number'>29</span>
<span class='line-number'>30</span>
<span class='line-number'>31</span>
<span class='line-number'>32</span>
<span class='line-number'>33</span>
<span class='line-number'>34</span>
<span class='line-number'>35</span>
<span class='line-number'>36</span>
<span class='line-number'>37</span>
<span class='line-number'>38</span>
<span class='line-number'>39</span>
<span class='line-number'>40</span>
<span class='line-number'>41</span>
<span class='line-number'>42</span>
<span class='line-number'>43</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kn">package</span> <span class="n">com</span><span class="o">.</span><span class="na">contrastofbeauty</span><span class="o">.</span><span class="na">tuts</span><span class="o">.</span><span class="na">concurrency</span><span class="o">.</span><span class="na">synchronizers</span><span class="o">.</span><span class="na">countdownlatch</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'><span class="kn">import</span> <span class="nn">java.util.concurrent.CountDownLatch</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'><span class="kd">public</span> <span class="kd">final</span> <span class="kd">class</span> <span class="nc">ClientExecutor</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">public</span> <span class="kd">static</span> <span class="kd">final</span> <span class="kt">int</span> <span class="n">COUNTDOWN_SECONDS</span> <span class="o">=</span> <span class="mi">10</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">public</span> <span class="kd">static</span> <span class="kd">final</span> <span class="kt">int</span> <span class="n">SECONDS_TO_WAIT</span> <span class="o">=</span> <span class="mi">1000</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">private</span> <span class="nf">ClientExecutor</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">public</span> <span class="kd">static</span> <span class="kt">void</span> <span class="nf">main</span><span class="o">(</span><span class="kd">final</span> <span class="n">String</span><span class="o">[]</span> <span class="n">args</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>        <span class="n">CountDownLatch</span> <span class="n">timer</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">CountDownLatch</span><span class="o">(</span><span class="n">COUNTDOWN_SECONDS</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>        <span class="c1">// all the runners each one represented by one thread</span>
</span><span class='line'>        <span class="k">new</span> <span class="nf">Thread</span><span class="o">(</span><span class="k">new</span> <span class="nf">Runner</span><span class="o">(</span><span class="n">timer</span><span class="o">),</span> <span class="s">&quot;Pietro Paolo Mennea&quot;</span><span class="o">).</span><span class="na">start</span><span class="o">();</span>
</span><span class='line'>        <span class="k">new</span> <span class="nf">Thread</span><span class="o">(</span><span class="k">new</span> <span class="nf">Runner</span><span class="o">(</span><span class="n">timer</span><span class="o">),</span> <span class="s">&quot;Sara Simeoni&quot;</span><span class="o">).</span><span class="na">start</span><span class="o">();</span>
</span><span class='line'>        <span class="k">new</span> <span class="nf">Thread</span><span class="o">(</span><span class="k">new</span> <span class="nf">Runner</span><span class="o">(</span><span class="n">timer</span><span class="o">),</span> <span class="s">&quot;Luigi Beccali&quot;</span><span class="o">).</span><span class="na">start</span><span class="o">();</span>
</span><span class='line'>        <span class="k">new</span> <span class="nf">Thread</span><span class="o">(</span><span class="k">new</span> <span class="nf">Runner</span><span class="o">(</span><span class="n">timer</span><span class="o">),</span> <span class="s">&quot;Adolfo Consolini&quot;</span><span class="o">).</span><span class="na">start</span><span class="o">();</span>
</span><span class='line'>        <span class="k">new</span> <span class="nf">Thread</span><span class="o">(</span><span class="k">new</span> <span class="nf">Runner</span><span class="o">(</span><span class="n">timer</span><span class="o">),</span> <span class="s">&quot;Maurizio Damilano&quot;</span><span class="o">).</span><span class="na">start</span><span class="o">();</span>
</span><span class='line'>
</span><span class='line'>        <span class="n">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="s">&quot;Timer started&quot;</span><span class="o">);</span>
</span><span class='line'>        <span class="n">Long</span> <span class="n">count</span> <span class="o">=</span> <span class="n">timer</span><span class="o">.</span><span class="na">getCount</span><span class="o">();</span>
</span><span class='line'>
</span><span class='line'>        <span class="k">while</span> <span class="o">(</span><span class="n">count</span> <span class="o">&gt;</span> <span class="mi">0</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>            <span class="k">try</span> <span class="o">{</span>
</span><span class='line'>                <span class="n">Thread</span><span class="o">.</span><span class="na">sleep</span><span class="o">(</span><span class="n">SECONDS_TO_WAIT</span><span class="o">);</span> <span class="c1">// simulate the passing of 1 sec.</span>
</span><span class='line'>                <span class="n">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">print</span><span class="o">(</span><span class="n">count</span> <span class="o">+</span> <span class="s">&quot; &quot;</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>                <span class="k">if</span> <span class="o">(</span><span class="n">count</span> <span class="o">==</span> <span class="mi">1</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>                    <span class="n">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="s">&quot;GO!&quot;</span><span class="o">);</span>
</span><span class='line'>                <span class="o">}</span>
</span><span class='line'>                <span class="n">timer</span><span class="o">.</span><span class="na">countDown</span><span class="o">();</span> <span class="c1">// decrement the timer of 1 unit</span>
</span><span class='line'>                <span class="n">count</span> <span class="o">=</span> <span class="n">timer</span><span class="o">.</span><span class="na">getCount</span><span class="o">();</span>
</span><span class='line'>            <span class="o">}</span> <span class="k">catch</span> <span class="o">(</span><span class="n">InterruptedException</span> <span class="n">e</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>                <span class="n">System</span><span class="o">.</span><span class="na">err</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="n">e</span><span class="o">);</span>
</span><span class='line'>            <span class="o">}</span>
</span><span class='line'>        <span class="o">}</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<h2><a id="exchanger">Exchanger</a></h2>

<h3>Scenario</h3>

<h3>Code</h3>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
<span class='line-number'>26</span>
<span class='line-number'>27</span>
<span class='line-number'>28</span>
<span class='line-number'>29</span>
<span class='line-number'>30</span>
<span class='line-number'>31</span>
<span class='line-number'>32</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kn">package</span> <span class="n">com</span><span class="o">.</span><span class="na">contrastofbeauty</span><span class="o">.</span><span class="na">tuts</span><span class="o">.</span><span class="na">concurrency</span><span class="o">.</span><span class="na">synchronizers</span><span class="o">.</span><span class="na">exchanger</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'><span class="kn">import</span> <span class="nn">java.util.concurrent.Exchanger</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">Friend</span> <span class="kd">implements</span> <span class="n">Runnable</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">private</span> <span class="n">Exchanger</span><span class="o">&lt;</span><span class="n">String</span><span class="o">&gt;</span> <span class="n">presents</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">private</span> <span class="n">String</span> <span class="n">name</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">private</span> <span class="n">String</span> <span class="n">present</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">public</span> <span class="nf">Friend</span><span class="o">(</span><span class="kd">final</span> <span class="n">Exchanger</span><span class="o">&lt;</span><span class="n">String</span><span class="o">&gt;</span> <span class="n">exchanger</span><span class="o">,</span> <span class="kd">final</span> <span class="n">String</span> <span class="n">friendName</span><span class="o">,</span> <span class="kd">final</span> <span class="n">String</span> <span class="n">presentToGive</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>        <span class="n">presents</span> <span class="o">=</span> <span class="n">exchanger</span><span class="o">;</span>
</span><span class='line'>        <span class="n">name</span> <span class="o">=</span> <span class="n">friendName</span><span class="o">;</span>
</span><span class='line'>        <span class="n">present</span> <span class="o">=</span> <span class="n">presentToGive</span><span class="o">;</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="nd">@Override</span>
</span><span class='line'>    <span class="kd">public</span> <span class="kd">final</span> <span class="kt">void</span> <span class="nf">run</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>        <span class="n">String</span> <span class="n">received</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>        <span class="n">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="n">name</span> <span class="o">+</span> <span class="s">&quot; give as a present &quot;</span> <span class="o">+</span> <span class="n">present</span><span class="o">);</span>
</span><span class='line'>        <span class="k">try</span> <span class="o">{</span>
</span><span class='line'>            <span class="n">received</span> <span class="o">=</span> <span class="n">presents</span><span class="o">.</span><span class="na">exchange</span><span class="o">(</span><span class="n">present</span><span class="o">);</span>
</span><span class='line'>            <span class="n">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="n">name</span> <span class="o">+</span> <span class="s">&quot; get as a present &quot;</span> <span class="o">+</span> <span class="n">received</span><span class="o">);</span>
</span><span class='line'>        <span class="o">}</span> <span class="k">catch</span> <span class="o">(</span><span class="n">InterruptedException</span> <span class="n">e</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>            <span class="n">System</span><span class="o">.</span><span class="na">err</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="n">e</span><span class="o">);</span>
</span><span class='line'>        <span class="o">}</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>




<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kn">package</span> <span class="n">com</span><span class="o">.</span><span class="na">contrastofbeauty</span><span class="o">.</span><span class="na">tuts</span><span class="o">.</span><span class="na">concurrency</span><span class="o">.</span><span class="na">synchronizers</span><span class="o">.</span><span class="na">exchanger</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'><span class="kn">import</span> <span class="nn">java.util.concurrent.Exchanger</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'><span class="kd">public</span> <span class="kd">final</span> <span class="kd">class</span> <span class="nc">ClientExecutor</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">private</span> <span class="nf">ClientExecutor</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">public</span> <span class="kd">static</span> <span class="kt">void</span> <span class="nf">main</span><span class="o">(</span><span class="kd">final</span> <span class="n">String</span><span class="o">[]</span> <span class="n">args</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>        <span class="c1">// object used to exchange presents between two friends</span>
</span><span class='line'>        <span class="n">Exchanger</span><span class="o">&lt;</span><span class="n">String</span><span class="o">&gt;</span> <span class="n">presents</span> <span class="o">=</span> <span class="k">new</span> <span class="n">Exchanger</span><span class="o">&lt;</span><span class="n">String</span><span class="o">&gt;();</span>
</span><span class='line'>
</span><span class='line'>        <span class="k">new</span> <span class="nf">Thread</span><span class="o">(</span><span class="k">new</span> <span class="nf">Friend</span><span class="o">(</span><span class="n">presents</span><span class="o">,</span> <span class="s">&quot;Alessandro Delpiero&quot;</span><span class="o">,</span> <span class="s">&quot;De Bello Gallico, di Giulio Cesare&quot;</span><span class="o">)).</span><span class="na">start</span><span class="o">();</span>
</span><span class='line'>        <span class="k">new</span> <span class="nf">Thread</span><span class="o">(</span><span class="k">new</span> <span class="nf">Friend</span><span class="o">(</span><span class="n">presents</span><span class="o">,</span> <span class="s">&quot;Michel Platini&quot;</span><span class="o">,</span> <span class="s">&quot;Fabulae, di Fedro&quot;</span><span class="o">)).</span><span class="na">start</span><span class="o">();</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<h2><a id="cyclicbarrier">CyclicBarrier</a></h2>

<h3>Scenario</h3>

<h3>Code</h3>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kn">package</span> <span class="n">com</span><span class="o">.</span><span class="na">contrastofbeauty</span><span class="o">.</span><span class="na">tuts</span><span class="o">.</span><span class="na">concurrency</span><span class="o">.</span><span class="na">synchronizers</span><span class="o">.</span><span class="na">cyclicbarrier</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">MeetingRoom</span> <span class="kd">extends</span> <span class="n">Thread</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="nd">@Override</span>
</span><span class='line'>    <span class="kd">public</span> <span class="kd">final</span> <span class="kt">void</span> <span class="nf">run</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>        <span class="n">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="s">&quot;All the participants have arrived at the meeting room.&quot;</span><span class="o">);</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>




<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
<span class='line-number'>26</span>
<span class='line-number'>27</span>
<span class='line-number'>28</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kn">package</span> <span class="n">com</span><span class="o">.</span><span class="na">contrastofbeauty</span><span class="o">.</span><span class="na">tuts</span><span class="o">.</span><span class="na">concurrency</span><span class="o">.</span><span class="na">synchronizers</span><span class="o">.</span><span class="na">cyclicbarrier</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'><span class="kn">import</span> <span class="nn">java.util.concurrent.BrokenBarrierException</span><span class="o">;</span>
</span><span class='line'><span class="kn">import</span> <span class="nn">java.util.concurrent.CyclicBarrier</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">Participant</span> <span class="kd">implements</span> <span class="n">Runnable</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">private</span> <span class="n">CyclicBarrier</span> <span class="n">meetingPoint</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">private</span> <span class="n">String</span> <span class="n">name</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">public</span> <span class="nf">Participant</span><span class="o">(</span><span class="kd">final</span> <span class="n">CyclicBarrier</span> <span class="n">barrier</span><span class="o">,</span> <span class="kd">final</span> <span class="n">String</span> <span class="n">partecipantName</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>        <span class="n">meetingPoint</span> <span class="o">=</span> <span class="n">barrier</span><span class="o">;</span>
</span><span class='line'>        <span class="n">name</span> <span class="o">=</span> <span class="n">partecipantName</span><span class="o">;</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="nd">@Override</span>
</span><span class='line'>    <span class="kd">public</span> <span class="kd">final</span> <span class="kt">void</span> <span class="nf">run</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>        <span class="n">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="n">name</span> <span class="o">+</span> <span class="s">&quot; arrived at the meeting point.&quot;</span><span class="o">);</span>
</span><span class='line'>        <span class="k">try</span> <span class="o">{</span>
</span><span class='line'>            <span class="n">meetingPoint</span><span class="o">.</span><span class="na">await</span><span class="o">();</span>
</span><span class='line'>        <span class="o">}</span> <span class="k">catch</span> <span class="o">(</span><span class="n">InterruptedException</span> <span class="n">e</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>            <span class="n">System</span><span class="o">.</span><span class="na">err</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="n">e</span><span class="o">);</span>
</span><span class='line'>        <span class="o">}</span> <span class="k">catch</span> <span class="o">(</span><span class="n">BrokenBarrierException</span> <span class="n">e</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>            <span class="n">System</span><span class="o">.</span><span class="na">err</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="n">e</span><span class="o">);</span>
</span><span class='line'>        <span class="o">}</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>




<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
<span class='line-number'>26</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kn">package</span> <span class="n">com</span><span class="o">.</span><span class="na">contrastofbeauty</span><span class="o">.</span><span class="na">tuts</span><span class="o">.</span><span class="na">concurrency</span><span class="o">.</span><span class="na">synchronizers</span><span class="o">.</span><span class="na">cyclicbarrier</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'><span class="kn">import</span> <span class="nn">java.util.concurrent.CyclicBarrier</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'><span class="kd">public</span> <span class="kd">final</span> <span class="kd">class</span> <span class="nc">ClientExecutor</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">private</span> <span class="nf">ClientExecutor</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">public</span> <span class="kd">static</span> <span class="kt">void</span> <span class="nf">main</span><span class="o">(</span><span class="kd">final</span> <span class="n">String</span><span class="o">[]</span> <span class="n">args</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>        <span class="cm">/**</span>
</span><span class='line'><span class="cm">         * Manage the meeting point, represented by a thread, for all the</span>
</span><span class='line'><span class="cm">         * registered threads. When all the threads have reached the meeting</span>
</span><span class='line'><span class="cm">         * point, the run() method of the meeting point thread is executed.</span>
</span><span class='line'><span class="cm">         */</span>
</span><span class='line'>        <span class="n">CyclicBarrier</span> <span class="n">barrier</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">CyclicBarrier</span><span class="o">(</span><span class="mi">5</span><span class="o">,</span> <span class="k">new</span> <span class="nf">MeetingRoom</span><span class="o">());</span>
</span><span class='line'>
</span><span class='line'>        <span class="c1">// participant to the meeting</span>
</span><span class='line'>        <span class="k">new</span> <span class="nf">Thread</span><span class="o">(</span><span class="k">new</span> <span class="nf">Participant</span><span class="o">(</span><span class="n">barrier</span><span class="o">,</span> <span class="s">&quot;Charlie Chaplin&quot;</span><span class="o">)).</span><span class="na">start</span><span class="o">();</span>
</span><span class='line'>        <span class="k">new</span> <span class="nf">Thread</span><span class="o">(</span><span class="k">new</span> <span class="nf">Participant</span><span class="o">(</span><span class="n">barrier</span><span class="o">,</span> <span class="s">&quot;Rodolfo Valentino&quot;</span><span class="o">)).</span><span class="na">start</span><span class="o">();</span>
</span><span class='line'>        <span class="k">new</span> <span class="nf">Thread</span><span class="o">(</span><span class="k">new</span> <span class="nf">Participant</span><span class="o">(</span><span class="n">barrier</span><span class="o">,</span> <span class="s">&quot;Buster Keaton&quot;</span><span class="o">)).</span><span class="na">start</span><span class="o">();</span>
</span><span class='line'>        <span class="k">new</span> <span class="nf">Thread</span><span class="o">(</span><span class="k">new</span> <span class="nf">Participant</span><span class="o">(</span><span class="n">barrier</span><span class="o">,</span> <span class="s">&quot;Roscoe Arbuckle&quot;</span><span class="o">)).</span><span class="na">start</span><span class="o">();</span>
</span><span class='line'>        <span class="k">new</span> <span class="nf">Thread</span><span class="o">(</span><span class="k">new</span> <span class="nf">Participant</span><span class="o">(</span><span class="n">barrier</span><span class="o">,</span> <span class="s">&quot;Max Linder&quot;</span><span class="o">)).</span><span class="na">start</span><span class="o">();</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>

]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Factory Pattern]]></title>
    <link href="http://blackat.github.io/blog/2013/05/21/factory-pattern/"/>
    <updated>2013-05-21T22:17:00+02:00</updated>
    <id>http://blackat.github.io/blog/2013/05/21/factory-pattern</id>
    <content type="html"><![CDATA[<h3>Introduction</h3>

<ul>
<li>An abstract factory method isolates the client from knowing what class is actually created.</li>
<li><strong>New</strong> operator means <em>directly instantiating</em> an object so <em>direct dependency on a concrete class</em>.

<ul>
<li>Code is not close to modification.</li>
</ul>
</li>
<li><strong>Interface and abstract class</strong> imply decoupling code from the actual object. If code is written to an interface it will work with any new class implementing that interface through polymorphism.</li>
<li><strong>Design principle.</strong> <a href="http://blackat.github.io/oo-design-principles/index.html#inversion_principle">Dependency Inversion Principle.</a></li>
</ul>


<!-- more -->


<h3>In a Nutshell</h3>

<ul>
<li><strong>All factory pattern.</strong>

<ul>
<li>Encapsulate object creation.</li>
<li>Promote <em>coding to abstraction</em> reducing dependency on concrete classes and improving loose coupling.</li>
<li>Client depends on <em>interfaces</em> removing direct object instantiation.</li>
<li>Hide object construction details from the client.</li>
</ul>
</li>
<li><strong>Simple factory.</strong>

<ul>
<li>Not a proper design pattern, but more a programming idiom.</li>
<li>A simple way to <em>decouple</em> a client from concrete classes.</li>
<li>Usually a factory class provides a static method to construct an object.</li>
</ul>
</li>
<li><strong>Factory method.</strong>

<ul>
<li>Is <em>abstract and protected</em> so defers the instantiation to its subclasses.</li>
<li><strong>Relies on inheritance</strong> that is object creation is delegated to the subclasses which implement the <em>abstract factory method</em> able to create objects.</li>
<li><strong>Design principle.</strong> <a href="http://blackat.github.io/oo-design-principles/index.html#inversion_principle">Dependency Inversion Principle.</a></li>
</ul>
</li>
<li><strong>Abstract factory.</strong>

<ul>
<li>Class whose interface is mostly made of abstract methods.</li>
<li>Creates a family of related objects without depending on <em>concrete classes</em>.</li>
<li><strong>relies on object composition</strong> that is object creation is implemented in methods exposed in the abstract factory class interface.</li>
</ul>
</li>
</ul>


<h2>1. Simple Factory</h2>

<ul>
<li><p><strong>Definition.</strong> It is not a proper design pattern, but more a programming idiom.</p></li>
<li><p><strong>Class diagram.</strong></p></li>
<li><p><strong>Simple factory in action.</strong></p>

<ul>
<li>The factory class is responsible to create different <em>concrete products</em> hiding construction details from the client.</li>
<li>Construction details are in a centralized place, easy to maintain.</li>
<li>The client is aware only about the <em>product interface</em> and not anymore tightly coupled to its concrete instantiation.</li>
<li>The factory class <em>encapsulate object creation,</em> not flexible and the creation of new products oblige to modify the class. A class should be closed to modification but open for extensions.</li>
</ul>
</li>
</ul>


<h3>Example</h3>

<p>Suppose a car manufacturer which has to build different models of cars but should not be aware of all the production details for each model. Better to use a factory that knows all the details for each model.</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">CarManufacturer</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">private</span> <span class="n">CarFactory</span> <span class="n">carFactory</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">public</span> <span class="nf">CarManufacturer</span><span class="o">(</span><span class="n">CarFactory</span> <span class="n">factory</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>        <span class="k">this</span><span class="o">.</span><span class="na">carFactory</span> <span class="o">=</span> <span class="n">factory</span><span class="o">;</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">public</span> <span class="n">AbstractCar</span> <span class="nf">buildCar</span><span class="o">(</span><span class="n">String</span> <span class="n">model</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>        <span class="n">AbstractCar</span> <span class="n">car</span> <span class="o">=</span> <span class="k">this</span><span class="o">.</span><span class="na">carFactory</span><span class="o">.</span><span class="na">createCarInstance</span><span class="o">(</span><span class="n">model</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>        <span class="n">Validate</span><span class="o">.</span><span class="na">notNull</span><span class="o">(</span><span class="n">car</span><span class="o">,</span> <span class="s">&quot;Model &quot;</span> <span class="o">+</span> <span class="n">model</span> <span class="o">+</span> <span class="s">&quot; is not available for the build.&quot;</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>        <span class="n">car</span><span class="o">.</span><span class="na">assemble</span><span class="o">();</span>
</span><span class='line'>        <span class="n">car</span><span class="o">.</span><span class="na">paint</span><span class="o">();</span>
</span><span class='line'>        <span class="n">car</span><span class="o">.</span><span class="na">mountWheels</span><span class="o">();</span>
</span><span class='line'>        <span class="n">car</span><span class="o">.</span><span class="na">test</span><span class="o">();</span>
</span><span class='line'>
</span><span class='line'>        <span class="k">return</span> <span class="n">car</span><span class="o">;</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>The factory knows, according to the model, which <em>concrete class</em> should be instantiated and returned. <code>CarManufacturer</code> HAS-A factory instance and the <code>buildCar</code> method returns an <code>abstract</code> car, so that programming to interfaces allow to return multiple object types.</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">CarFactory</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">public</span> <span class="kd">static</span> <span class="kd">final</span> <span class="n">String</span> <span class="n">A_CLASS</span> <span class="o">=</span> <span class="s">&quot;a-class&quot;</span><span class="o">;</span>
</span><span class='line'>    <span class="kd">public</span> <span class="kd">static</span> <span class="kd">final</span> <span class="n">String</span> <span class="n">B_CLASS</span> <span class="o">=</span> <span class="s">&quot;b-class&quot;</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">public</span> <span class="n">AbstractCar</span> <span class="nf">createCarInstance</span><span class="o">(</span><span class="n">String</span> <span class="n">model</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>        <span class="k">if</span> <span class="o">(</span><span class="n">model</span><span class="o">.</span><span class="na">equalsIgnoreCase</span><span class="o">(</span><span class="n">A_CLASS</span><span class="o">))</span> <span class="o">{</span>
</span><span class='line'>            <span class="k">return</span> <span class="k">new</span> <span class="nf">ClassA</span><span class="o">();</span>
</span><span class='line'>        <span class="o">}</span> <span class="k">else</span> <span class="nf">if</span> <span class="o">(</span><span class="n">model</span><span class="o">.</span><span class="na">equalsIgnoreCase</span><span class="o">(</span><span class="n">B_CLASS</span><span class="o">))</span> <span class="o">{</span>
</span><span class='line'>            <span class="k">return</span> <span class="k">new</span> <span class="nf">ClassB</span><span class="o">();</span>
</span><span class='line'>        <span class="o">}</span>
</span><span class='line'>        <span class="k">return</span> <span class="kc">null</span><span class="o">;</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>Finally the test class shows how</p>

<ul>
<li>implementation details of each model are hidden to the client,</li>
<li>different factory instances could be passed to the car manufacturer at runtime,</li>
<li>client is not aware of the concrete object type returned by the factory, but just knows the interface implemented.</li>
</ul>


<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
<span class='line-number'>26</span>
<span class='line-number'>27</span>
<span class='line-number'>28</span>
<span class='line-number'>29</span>
<span class='line-number'>30</span>
<span class='line-number'>31</span>
<span class='line-number'>32</span>
<span class='line-number'>33</span>
<span class='line-number'>34</span>
<span class='line-number'>35</span>
<span class='line-number'>36</span>
<span class='line-number'>37</span>
<span class='line-number'>38</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">CarManufacturerTest</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">private</span> <span class="n">CarManufacturer</span> <span class="n">carManufacturer</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>    <span class="nd">@Before</span>
</span><span class='line'>    <span class="kd">public</span> <span class="kt">void</span> <span class="nf">setUp</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>        <span class="n">carManufacturer</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">CarManufacturer</span><span class="o">(</span><span class="k">new</span> <span class="nf">CarFactory</span><span class="o">());</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="nd">@Test</span>
</span><span class='line'>    <span class="kd">public</span> <span class="kt">void</span> <span class="nf">testBuildCarExistingModelClassA</span><span class="o">()</span> <span class="kd">throws</span> <span class="n">Exception</span> <span class="o">{</span>
</span><span class='line'>        <span class="n">AbstractCar</span> <span class="n">car</span> <span class="o">=</span> <span class="n">carManufacturer</span><span class="o">.</span><span class="na">buildCar</span><span class="o">(</span><span class="s">&quot;a-class&quot;</span><span class="o">);</span>
</span><span class='line'>        <span class="n">assertCarBuilt</span><span class="o">(</span><span class="n">car</span><span class="o">);</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="nd">@Test</span>
</span><span class='line'>    <span class="kd">public</span> <span class="kt">void</span> <span class="nf">testBuildCarExistingModelClassB</span><span class="o">()</span> <span class="kd">throws</span> <span class="n">Exception</span> <span class="o">{</span>
</span><span class='line'>        <span class="n">AbstractCar</span> <span class="n">car</span> <span class="o">=</span> <span class="n">carManufacturer</span><span class="o">.</span><span class="na">buildCar</span><span class="o">(</span><span class="s">&quot;b-class&quot;</span><span class="o">);</span>
</span><span class='line'>        <span class="n">assertCarBuilt</span><span class="o">(</span><span class="n">car</span><span class="o">);</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">private</span> <span class="kt">void</span> <span class="nf">assertCarBuilt</span><span class="o">(</span><span class="n">AbstractCar</span> <span class="n">car</span><span class="o">)</span> <span class="kd">throws</span> <span class="n">Exception</span> <span class="o">{</span>
</span><span class='line'>        <span class="n">assertTrue</span><span class="o">(</span><span class="n">car</span><span class="o">.</span><span class="na">isAssembled</span><span class="o">());</span>
</span><span class='line'>        <span class="n">assertTrue</span><span class="o">(</span><span class="n">car</span><span class="o">.</span><span class="na">isPainted</span><span class="o">());</span>
</span><span class='line'>        <span class="n">assertTrue</span><span class="o">(</span><span class="n">car</span><span class="o">.</span><span class="na">isWheelsMounted</span><span class="o">());</span>
</span><span class='line'>        <span class="n">assertTrue</span><span class="o">(</span><span class="n">car</span><span class="o">.</span><span class="na">isTested</span><span class="o">());</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="nd">@Rule</span>
</span><span class='line'>    <span class="kd">public</span> <span class="n">ExpectedException</span> <span class="n">thrown</span> <span class="o">=</span> <span class="n">ExpectedException</span><span class="o">.</span><span class="na">none</span><span class="o">();</span>
</span><span class='line'>
</span><span class='line'>    <span class="nd">@Test</span>
</span><span class='line'>    <span class="kd">public</span> <span class="kt">void</span> <span class="nf">testBuildCarNotExistingModel</span><span class="o">()</span> <span class="kd">throws</span> <span class="n">Exception</span> <span class="o">{</span>
</span><span class='line'>        <span class="n">thrown</span><span class="o">.</span><span class="na">expect</span><span class="o">(</span><span class="n">IllegalArgumentException</span><span class="o">.</span><span class="na">class</span><span class="o">);</span>
</span><span class='line'>        <span class="n">thrown</span><span class="o">.</span><span class="na">expectMessage</span><span class="o">(</span><span class="s">&quot;Model c-class is not available for the build.&quot;</span><span class="o">);</span>
</span><span class='line'>        <span class="n">AbstractCar</span> <span class="n">car</span> <span class="o">=</span> <span class="n">carManufacturer</span><span class="o">.</span><span class="na">buildCar</span><span class="o">(</span><span class="s">&quot;c-class&quot;</span><span class="o">);</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<h2>2. Factory Method</h2>

<ul>
<li><p><strong>Definition.</strong> Defines a <em>method interface</em> to create an object and lets subclasses decide which class should be instantiated. Thus the instantiation of the concrete class is deferred to subclasses.</p></li>
<li><p><strong>Design principle.</strong> The dependency inversion principle.</p></li>
<li><p><strong>Class diagram.</strong></p></li>
</ul>


<p><img src="http://blackat.github.io/images/posts/design-patterns/factory_method.png"></p>

<ul>
<li><strong>Factory method in action.</strong>

<ul>
<li>With respect to the simple factory, the factory method gets rid of the external factory class and localize the making activity in the client class which is then abstract.</li>
<li>The creation activity is concentrated into a method which acts as a <em>factory.</em></li>
<li>Parallel class hierarchies, both the creator and the product hierarchy start from an abstract class.

<ul>
<li>Each class extending the abstract one, the client, is called <strong>creator class</strong> and many of them could be defined.</li>
<li>The product class is abstract as well, so many product classes could be available.</li>
</ul>
</li>
<li>Subclasses decide which implementation will be used, so more flexibility and products can vary.</li>
</ul>
</li>
</ul>


<h3>Example</h3>

<p>Get rid of the external factory and defines <em>within the client class</em> an <em>abstract method</em> which acts as a factory. The advantage of this design is infinite extension of the class to add new models without changing the factory.</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="kd">abstract</span> <span class="kd">class</span> <span class="nc">AbstractCarManufacturer</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">public</span> <span class="nf">AbstractCarManufacturer</span><span class="o">()</span> <span class="o">{</span> <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">public</span> <span class="kd">final</span> <span class="n">AbstractCar</span> <span class="nf">buildCar</span><span class="o">(</span><span class="kd">final</span> <span class="n">String</span> <span class="n">model</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>        <span class="n">AbstractCar</span> <span class="n">car</span> <span class="o">=</span> <span class="n">createCar</span><span class="o">(</span><span class="n">model</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>        <span class="n">Validate</span><span class="o">.</span><span class="na">notNull</span><span class="o">(</span><span class="n">car</span><span class="o">,</span> <span class="s">&quot;Model &quot;</span> <span class="o">+</span> <span class="n">model</span> <span class="o">+</span> <span class="s">&quot; is not available for the build.&quot;</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>        <span class="n">car</span><span class="o">.</span><span class="na">assemble</span><span class="o">();</span>
</span><span class='line'>        <span class="n">car</span><span class="o">.</span><span class="na">paint</span><span class="o">();</span>
</span><span class='line'>        <span class="n">car</span><span class="o">.</span><span class="na">mountWheels</span><span class="o">();</span>
</span><span class='line'>        <span class="n">car</span><span class="o">.</span><span class="na">test</span><span class="o">();</span>
</span><span class='line'>
</span><span class='line'>        <span class="k">return</span> <span class="n">car</span><span class="o">;</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">protected</span> <span class="kd">abstract</span> <span class="n">AbstractCar</span> <span class="nf">createCar</span><span class="o">(</span><span class="kd">final</span> <span class="n">String</span> <span class="n">model</span><span class="o">);</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>Now the concrete client class implements the factory method and many clients can be defined to create different models.</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">FamilyCarManufacturer</span> <span class="kd">extends</span> <span class="n">AbstractCarManufacturer</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">public</span> <span class="kd">static</span> <span class="kd">final</span> <span class="n">String</span> <span class="n">C_CLASS</span> <span class="o">=</span> <span class="s">&quot;c-class&quot;</span><span class="o">;</span>
</span><span class='line'>    <span class="kd">public</span> <span class="kd">static</span> <span class="kd">final</span> <span class="n">String</span> <span class="n">E_CLASS</span> <span class="o">=</span> <span class="s">&quot;e-class&quot;</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>    <span class="nd">@Override</span>
</span><span class='line'>    <span class="kd">public</span> <span class="n">AbstractCar</span> <span class="nf">createCar</span><span class="o">(</span><span class="kd">final</span> <span class="n">String</span> <span class="n">model</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>        <span class="k">if</span> <span class="o">(</span><span class="n">model</span><span class="o">.</span><span class="na">equalsIgnoreCase</span><span class="o">(</span><span class="n">C_CLASS</span><span class="o">))</span> <span class="o">{</span>
</span><span class='line'>            <span class="k">return</span> <span class="k">new</span> <span class="nf">ClassC</span><span class="o">();</span>
</span><span class='line'>        <span class="o">}</span> <span class="k">else</span> <span class="nf">if</span> <span class="o">(</span><span class="n">model</span><span class="o">.</span><span class="na">equalsIgnoreCase</span><span class="o">(</span><span class="n">E_CLASS</span><span class="o">))</span> <span class="o">{</span>
</span><span class='line'>            <span class="k">return</span> <span class="k">new</span> <span class="nf">ClassE</span><span class="o">();</span>
</span><span class='line'>        <span class="o">}</span>
</span><span class='line'>        <span class="k">return</span> <span class="kc">null</span><span class="o">;</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>Another manufacturer able to created different kinds of models.</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">SportCarManufacturer</span> <span class="kd">extends</span> <span class="n">AbstractCarManufacturer</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>    <span class="kd">public</span> <span class="kd">static</span> <span class="kd">final</span> <span class="n">String</span> <span class="n">SLK_CLASS</span> <span class="o">=</span> <span class="s">&quot;slk-class&quot;</span><span class="o">;</span>
</span><span class='line'>    <span class="kd">public</span> <span class="kd">static</span> <span class="kd">final</span> <span class="n">String</span> <span class="n">SLR_CLASS</span> <span class="o">=</span> <span class="s">&quot;slr-class&quot;</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>    <span class="nd">@Override</span>
</span><span class='line'>    <span class="kd">public</span> <span class="n">AbstractCar</span> <span class="nf">createCar</span><span class="o">(</span><span class="kd">final</span> <span class="n">String</span> <span class="n">model</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>        <span class="k">if</span> <span class="o">(</span><span class="n">model</span><span class="o">.</span><span class="na">equalsIgnoreCase</span><span class="o">(</span><span class="n">SLK_CLASS</span><span class="o">))</span> <span class="o">{</span>
</span><span class='line'>            <span class="k">return</span> <span class="k">new</span> <span class="nf">ClassA</span><span class="o">();</span>
</span><span class='line'>        <span class="o">}</span> <span class="k">else</span> <span class="nf">if</span> <span class="o">(</span><span class="n">model</span><span class="o">.</span><span class="na">equalsIgnoreCase</span><span class="o">(</span><span class="n">SLR_CLASS</span><span class="o">))</span> <span class="o">{</span>
</span><span class='line'>            <span class="k">return</span> <span class="k">new</span> <span class="nf">ClassB</span><span class="o">();</span>
</span><span class='line'>        <span class="o">}</span>
</span><span class='line'>        <span class="k">return</span> <span class="kc">null</span><span class="o">;</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<h2>3. Abstract Factory Method</h2>

<ul>
<li><strong>Definition.</strong> Provide and interface for creating families of related or dependent objects without specifying their concrete classes.</li>
<li><strong>Class diagram.</strong></li>
</ul>


<p><img src="http://blackat.github.io/images/posts/design-patterns/abstract_factory.png">
* <strong>Class diagram explained.</strong>
    * The <code>Client</code> defines an <code>AbstractFactory</code> variable and the actual factory will be resolved at runtime.
    * The <code>AbstractFactory</code> defines an <em>interface</em>.
    * Each <code>ConcreteFactory</code> represents a <em>family of products</em> and implements the method defined in the abstract interface. <code>ConcreteFactory2</code> for instance produces the set of products represented by <code>ProductA2</code> and <code>ProductB2</code>.
    * The <em>product family</em> is represented by the two interfaces <code>AbstractProductA</code> and <code>AbstractProductB</code>.
* <strong>Factory method in action.</strong>
    * The job of an Abstract Factory is to define an interface for creating a set of products through a set of methods.
    * Each product method in an interface is responsible to create a product.
    * Subclasses of the Abstract Factory provides the implementations.
    * Factory Methods are a natural way to implement the product methods in the abstract factories.
* <strong>Comparison.</strong>
    * <strong>Abstract factory</strong> creates a <em>family or set of products</em>.
    * <strong>Method factory</strong> creates a <em>single product</em>.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[MVC Pattern]]></title>
    <link href="http://blackat.github.io/blog/2013/03/28/mvc-pattern/"/>
    <updated>2013-03-28T22:42:00+01:00</updated>
    <id>http://blackat.github.io/blog/2013/03/28/mvc-pattern</id>
    <content type="html"><![CDATA[<blockquote><p>The MVC Pattern combines three patterns into a solution that separate the responsibilities in managing an interaction.</p><footer><strong>Bates and Sierra,</strong> <cite><a href='http://shop.oreilly.com/product/9780596007126.do'>Head First Design Patterns</a></cite></footer></blockquote>


<!-- more -->


<h2>Class diagram</h2>

<p><img src="http://blackat.github.io/images/posts/design-patterns/mvc_pattern.png"></p>

<ul>
<li><strong>View</strong> present the model usually in graphic interface.</li>
<li><strong>Controller</strong> takes user input, interpreting them to change the model, translates input into actions on the model.</li>
<li><strong>Model</strong> holds all the data, state and application logic, sends notifications of state changes to the observers.</li>
</ul>


<p>According to the interaction shown</p>

<ol>
<li>The <em>user</em> does something.</li>
<li>The <em>controller</em> gets the input (action and/or parameters), interprets them and figures out how to change the state of the <em>model</em> based on that action. The controller can also ask the view to change such as enable or disable certain buttons.</li>
<li>The <em>model</em> handles all the application data and logic.</li>
<li>The <em>model</em> notifies the <em>view</em> that its state has changed.</li>
<li>The <em>view</em> gets the state of the <em>model</em> to update itself.</li>
</ol>


<h2>Patterns</h2>

<h3>Strategy Pattern</h3>

<p>Implemented by the <em>view</em> and the <em>controller</em>. It decouples the view from the model because the controller is responsible for interacting with the <em>model</em> to carry out user requests. The view doesn&rsquo;t know how the request will be interpreted to change the model.</p>

<p>The view delegates to the controller to handle the user actions. The controller is the object that knows how to handle the user actions.</p>

<h3>Composite</h3>

<p>The view is a composite of GUI components, the top level contains other components which contain components and so on until the leaf.</p>

<h3>Observer</h3>

<p>The model is the <em>observable</em> and the view is the <em>observer</em> which registers with the model.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Command Pattern]]></title>
    <link href="http://blackat.github.io/blog/2013/03/28/command-pattern/"/>
    <updated>2013-03-28T18:26:00+01:00</updated>
    <id>http://blackat.github.io/blog/2013/03/28/command-pattern</id>
    <content type="html"><![CDATA[<blockquote><p>The Command Pattern encapsulates a request as an object, thereby letting you parameterize other objects with different requests, queue or log requests, and support undoable operations.</p><footer><strong>Bates and Sierra,</strong> <cite><a href='http://shop.oreilly.com/product/9780596007126.do'>Head First Design Patterns</a></cite></footer></blockquote>


<!-- more -->


<h2>Class diagram</h2>

<p><img src="http://blackat.github.io/images/posts/design-patterns/command_pattern.png"></p>

<ul>
<li><code>Client</code> creates the <code>ConcreteCommand</code> and sets its <code>Receiver</code>.</li>
<li><code>Receiver</code> knows how to perform the work to carry out the request.</li>
<li><code>ConcreteCommand</code> defines a binding between an action and a <code>Receiver</code>.</li>
<li><code>Invoker</code> makes a request calling <em>execute()</em> method, the <code>ConcreteCommand</code> carries the request out calling one or more actions on the <code>Receiver</code>.</li>
</ul>


<h2>Key Points</h2>

<h2>Command in Action</h2>

<p><strong>Scenario.</strong> The idea is to implement a remote to control different devices in a house such as the lights, the gate, the door of the garage and so on. Imagine to have a remote having different buttons and to be able to connect to each button a device.</p>

<p>Each device could work in a different way from the others, a gate opens and closes, the light turn on and off. Idea is to abstract from the specific action to be performed and having a common interface.</p>

<h3>Command interface</h3>

<p>This interface must be implemented by a command object which <em>wraps</em> the <code>Receiver</code> and collect some action over it in the <code>execute()</code> method.</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="kd">interface</span> <span class="nc">Command</span> <span class="o">{</span>
</span><span class='line'>  <span class="kt">void</span> <span class="nf">execute</span><span class="o">();</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<h3>Receiver</h3>

<p>The light is the <code>Receiver</code> of the <em>request</em>, it is the device produced by a <em>specific vendor</em>. It has a specific interface which describes, through the methods, the possible behavior of the device.</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">Light</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>  <span class="kd">private</span> <span class="kt">boolean</span> <span class="n">on</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>  <span class="kd">public</span> <span class="kt">void</span> <span class="nf">on</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>      <span class="n">on</span> <span class="o">=</span> <span class="kc">true</span><span class="o">;</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>  <span class="kd">public</span> <span class="kt">void</span> <span class="nf">off</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>      <span class="n">on</span> <span class="o">=</span> <span class="kc">false</span><span class="o">;</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<h3>Concrete Command</h3>

<p>The <code>LightCommand</code> is a <em>wrapper</em> for the <code>Receiver</code>, the device the request has to be delegated to. The method <code>execute()</code> group a set of action which will be invoked over the <code>Receiver</code>.</p>

<p>In general a command represent a specific action on a device such as turn on or turn off the light. Each command is then assign to a button on the remote.</p>

<p>The <em>command object</em> encapsulate a request of a device, it is used to make requests, each request will be delegated to the wrapped <code>Receiver</code>.
This class is a <em>command</em> and could be implemented by the vendor with specific actions for the controlled device.</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">LightOnCommand</span> <span class="kd">implements</span> <span class="n">Command</span><span class="o">{</span>
</span><span class='line'>
</span><span class='line'>  <span class="n">Light</span> <span class="n">light</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>  <span class="kd">public</span> <span class="nf">LightCommand</span><span class="o">(</span><span class="n">Light</span> <span class="n">light</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>      <span class="k">this</span><span class="o">.</span><span class="na">light</span> <span class="o">=</span> <span class="n">light</span><span class="o">;</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>  <span class="nd">@Override</span>
</span><span class='line'>  <span class="kd">public</span> <span class="kt">void</span> <span class="nf">execute</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>      <span class="n">light</span><span class="o">.</span><span class="na">on</span><span class="o">();</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p>Another command to be assigned to another button.</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">LightOffCommand</span> <span class="kd">implements</span> <span class="n">Command</span><span class="o">{</span>
</span><span class='line'>
</span><span class='line'>  <span class="c1">// same code</span>
</span><span class='line'>
</span><span class='line'>  <span class="nd">@Override</span>
</span><span class='line'>  <span class="kd">public</span> <span class="kt">void</span> <span class="nf">execute</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>      <span class="n">light</span><span class="o">.</span><span class="na">off</span><span class="o">();</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<h3>Invoker</h3>

<p>The <code>RemoteControl</code> class is the <code>Invoker</code> which, in this case, has only one button as stated by the <code>slot</code> variable, able to <em>hold a device to control</em>. When the <code>Client</code> presses the button, the method <code>buttonPressed()</code> is invoked.</p>

<p>The <code>Invoker</code> manages the command objects, one per button. In this case there is only one button.</p>

<p>The client is decoupled from the specific device interface, he doesn&rsquo;t have to know the details of the device that is how to turn on or of the light, he has just to press a button.</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">RemoteControl</span> <span class="o">{</span>
</span><span class='line'>  <span class="n">Command</span> <span class="n">slot</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>  <span class="kd">public</span> <span class="kt">void</span> <span class="nf">setCommand</span><span class="o">(</span><span class="n">Command</span> <span class="n">command</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>      <span class="n">slot</span> <span class="o">=</span> <span class="n">command</span><span class="o">;</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>  <span class="kd">public</span> <span class="kt">void</span> <span class="nf">buttonPressed</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>      <span class="n">slot</span><span class="o">.</span><span class="na">execute</span><span class="o">();</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<h3>Client</h3>

<p>The client prepare the remote to be used loading command objects in the specific slots. Each command object encapsulate a request of a device.
doesn&rsquo;t use the device, that is the <code>Receviver</code>, directly but through the <code>Invoker</code> which is the remote control.</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">Client</span> <span class="o">{</span>
</span><span class='line'>  <span class="kd">public</span> <span class="kd">static</span> <span class="kt">void</span> <span class="nf">main</span><span class="o">(</span><span class="n">String</span><span class="o">[]</span> <span class="n">args</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>      <span class="c1">// invoker</span>
</span><span class='line'>      <span class="n">RemoteControl</span> <span class="n">remoteControl</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">RemoteControl</span><span class="o">();</span>
</span><span class='line'>
</span><span class='line'>      <span class="c1">// receiver</span>
</span><span class='line'>      <span class="n">Light</span> <span class="n">light</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">Light</span><span class="o">();</span>
</span><span class='line'>
</span><span class='line'>      <span class="c1">// create a command and pass the receiver</span>
</span><span class='line'>      <span class="n">Command</span> <span class="n">command</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">LightCommand</span><span class="o">(</span><span class="n">light</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>      <span class="c1">// pass the command to the invoker</span>
</span><span class='line'>      <span class="n">remoteControl</span><span class="o">.</span><span class="na">setCommand</span><span class="o">(</span><span class="n">command</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>      <span class="c1">// press the button</span>
</span><span class='line'>      <span class="n">remoteControl</span><span class="o">.</span><span class="na">buttonPressed</span><span class="o">();</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>

]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Facade Pattern]]></title>
    <link href="http://blackat.github.io/blog/2013/03/27/facade-pattern/"/>
    <updated>2013-03-27T08:02:00+01:00</updated>
    <id>http://blackat.github.io/blog/2013/03/27/facade-pattern</id>
    <content type="html"><![CDATA[<blockquote><p>The Facade Pattern provides a unified interface to a set of interfaces in a subsystem. Facade defines a higher-level interface that makes the subsystem easier to use.</p><footer><strong>Bates and Sierra,</strong> <cite><a href='http://shop.oreilly.com/product/9780596007126.do'>Head First Design Patterns</a></cite></footer></blockquote>


<!-- more -->


<h2>Class diagram</h2>

<p><img src="http://blackat.github.io/images/posts/design-patterns/facade_pattern.png"></p>

<p>The <code>Facade</code> is a <em>unified interface</em> easily usable by the client which doesn&rsquo;t dialog anymore with the complex subsytem.</p>

<h2>Design Principle</h2>

<p>Principle of <em>Least Knowledge</em>, talk only to you immediate friends.</p>

<ul>
<li><strong>Loosely coupled system.</strong> Prevent from creating designs that have a large number of classes coupled together so that changes in one part of the system cascade on the other parts.</li>
<li><strong>Fragile system.</strong> It happens when there are a lot of dependencies between many classes.</li>
</ul>


<h2>Key Points</h2>

<ul>
<li><strong>Only one friend.</strong> The <em>client</em> has only one friend, the facade.</li>
<li><strong>Decoupling.</strong> Allow to decouple client implementation from any subsystem. Coding to the facade, rather than to the subystem, allows the client code to not change every time the subsystem changes, just the facade has to update.</li>
<li><strong>Delegation.</strong> Implementing the facade requires to compose the facade with its subsystem and use <em>delegation</em> to perform the work.</li>
<li><strong>Subsytem update.</strong> The update doesn&rsquo;t affect the client.</li>
<li><strong>Additional facade.</strong> If the subsystem gets too complex <em>additional facade</em> could be introduced to <em>form layers of subsystems</em>.</li>
<li><strong>Not encapsulate.</strong> The Facade doesn&rsquo;t encapsulate the classes but provides a simpler interface to the client. The subsystem classes can be still used by the client to achieve some low levels functionality.</li>
<li><strong>Many facades.</strong> Given a subsystem many facades can be created.</li>
</ul>


<h2>Comparison</h2>

<ul>
<li><strong>Wrap multiple classes.</strong> Both can wrap multiple classes.</li>
<li><strong>Facade</strong>

<ul>
<li>Simplify an interface.</li>
<li>Decouple a client from a subsystem of components</li>
<li>Subsystem classes are still available to the client for low level functionality.</li>
</ul>
</li>
<li><strong>Adapter</strong>

<ul>
<li>Convert an interface into something different, something the client is expecting.</li>
<li>Encapsulate the subsystem in order to hide it to the client which will use just the adapter interface.</li>
</ul>
</li>
</ul>

]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Adapter Pattern]]></title>
    <link href="http://blackat.github.io/blog/2013/03/27/adapter-pattern/"/>
    <updated>2013-03-27T08:01:00+01:00</updated>
    <id>http://blackat.github.io/blog/2013/03/27/adapter-pattern</id>
    <content type="html"><![CDATA[<blockquote><p>The Adapter Method Pattern converts the interface of a class into another interface the clients expect. Adapter lets classes work together that couldn&#8217;t otherwise because of incompatible interfaces.</p><footer><strong>Bates and Sierra,</strong> <cite><a href='http://shop.oreilly.com/product/9780596007126.do'>Head First Design Patterns</a></cite></footer></blockquote>


<!-- more -->


<h2>Class diagram</h2>

<p><img src="http://blackat.github.io/images/posts/design-patterns/adapter_pattern.png"></p>

<ul>
<li>Client can see only the <code>Target</code> interface.</li>
<li><code>Adapter</code> implements the <code>Target</code> interface and is composed with the <code>Adaptee</code> to which translates or delegates all the requests.</li>
<li><code>Adaptee</code> gets all the requests delegated by the <code>Adapter</code>.</li>
</ul>


<h2>Scenario</h2>

<h2>Key Points</h2>

<ul>
<li><strong>Object composition.</strong> The pattern <em>wraps</em> the <em>adaptee</em> with an <em>altered interface</em> and it can use any <em>subclass</em> of the adaptee.</li>
<li><strong>Bind to an interface.</strong> The pattern binds the client to an interface and not to an implementation.</li>
<li><strong>Adapter.</strong>

<ul>
<li><strong>Decouple</strong> the client from the implemented interface.</li>
<li><strong>Encapsulate what changes</strong> so the client doesn&rsquo;t have to modify each time needs to operate against a different interface.</li>
<li><strong>Convert</strong> one interface to another so the <em>adapter</em> could wrap one or more <em>adaptee</em> but it would be a bit messy (see Facade Pattern).</li>
<li><strong>Implement</strong> the interface of the type the client is expecting.</li>
<li><strong>Delegate</strong> all the requests to the object it wraps.</li>
<li><strong>Two ways Adapter.</strong> A client could expect old and new interfaces, so the adapter <em>implement both interfaces</em> to support the client.</li>
</ul>
</li>
</ul>


<h2>Adapter vs. Decorator</h2>

<ul>
<li><strong>Focus on</strong>

<ul>
<li><em>Adapter</em> convert the interface of what it wrap, <em>decorator</em> not change the interface.</li>
</ul>
</li>
<li><strong>Decorator</strong>

<ul>
<li>Wrapped many other adapters.</li>
<li>Add new behaviors.</li>
</ul>
</li>
<li><strong>Adapter</strong>

<ul>
<li>Allow clients to use other libraries without changing any code.</li>
</ul>
</li>
</ul>


<h2>Real World Adapters</h2>

<ul>
<li>Enumerator. Allow iterate over a collection elements without knowing the collection implementation details.</li>
<li>Iterator. Like the enumerator but with also the remove method.</li>
</ul>


<p><code>Enumerator</code> is the old fashion interface to iterate the collection elements so an adapter could <em>adapt</em> the old fashion to the new one.</p>

<ul>
<li><strong>Target interface.</strong> <code>Iterator</code></li>
<li><strong>Adaptee interface.</strong> <code>Enumeration</code></li>
<li>The <code>Adapter</code> has to implement the <code>Target</code> and to compose with the <code>Adaptee</code>.</li>
</ul>

]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Template Pattern]]></title>
    <link href="http://blackat.github.io/blog/2013/03/26/template-pattern/"/>
    <updated>2013-03-26T01:00:00+01:00</updated>
    <id>http://blackat.github.io/blog/2013/03/26/template-pattern</id>
    <content type="html"><![CDATA[<blockquote><p>The Template Method Pattern defines the skeleton of an algorithm in an operation, deferring some steps to subclasses. Template Method lets subclasses redefine certain steps of an algorithm without changing the algorithm&#8217;s structure.</p><footer><strong>Bates and Sierra,</strong> <cite><a href='http://shop.oreilly.com/product/9780596007126.do'>Head First Design Patterns</a></cite></footer></blockquote>


<!-- more -->


<h2>Class diagram</h2>

<p><img src="http://blackat.github.io/images/posts/design-patterns/template_method.png"></p>

<p>The abstract class contains the <em>template method</em> and <em>abstract</em> versions of the operations used in the template method. Each method, abstract or concrete, is a step of an algorithm which could varies.</p>

<p>The template methods use the <code>primitiveOperations</code> to implement an algorithm <em>decoupling</em> from the actual implementation of these operations.</p>

<p>The concrete class implements all the abstract operations called by the template method.</p>

<h2>Design Principle</h2>

<p><a href="http://blackat.github.io/oo-design-principles/index.html#hollywood_principle">The Hollywood Principle.</a></p>

<h2>Scenario</h2>

<p>An algorithm is made of steps useful to accomplish some tasks. It can be imagined as a recipe which is a set of instruction to prepare a dish. Some recipes could have some instructions in common so it should be better to avoid <em>code duplication</em>.</p>

<h2>Key Points</h2>

<ul>
<li><strong>Template method.</strong> It defines the skeleton of an algorithm <em>deferring</em> some steps to subclasses. It lets subclasses <em>redefine</em> some steps without changing the algorithm&rsquo;s structure.</li>
<li><strong>Abstract class.</strong>_

<ul>
<li>It is a template of methods for an algorithm which could implemented in slightly different ways in some of the steps.</li>
<li>It is made to be extended and abstract methods to be implemented. So the abstract class collect all the all the <em>common</em> methods or instructions different algorithms.</li>
<li>It reduces the dependencies in the system.</li>
</ul>
</li>
<li><strong>Abstract methods.</strong> They point out that they are just <em>placeholders</em> because they are in common with all the algorithms but their <em>implementation differ</em> from algorithm to algorithm.</li>
<li><strong>Concrete methods.</strong> Concrete meaning that their <em>implementation is the same and in common</em> among algorithms.</li>
<li><strong>Inheritance.</strong> It allows all the subclasses, the <em>algorithms</em>, to have the <em>same behaviors</em> of the superclass, if they are <em>abstract</em> they could change across subclasses.</li>
<li><strong>Interfaces.</strong> They don&rsquo;t have code so <em>no code reuse</em>.</li>
<li><strong>Concrete class.</strong> Concrete implementation is a working algorithm which implements each <em>abstract method</em> and <em>could add some other algorithm specific methods</em>.</li>
<li><strong>Hook methods.</strong>

<ul>
<li>They are concrete methods <em>doing nothing by default</em>, they are <em>optional steps of the algorithm</em> and the subclasses are not obliged to override them. The subclass can hook its own code into the algorithm, <em>an optional part of the algorithm</em>.</li>
<li>They could also be used to <em>conditionally control</em>, using conditional statements, the flow of the algorithm in the abstract class.</li>
</ul>
</li>
</ul>


<h2>Template method vs. Strategy</h2>

<ul>
<li><strong>Focus on</strong>

<ul>
<li>Strategy and Template both encapsulate algorithms, one by <em>inheritance</em> and one by <em>composition</em>.</li>
</ul>
</li>
<li><strong>Template</strong>

<ul>
<li>Define the <em>outline of an algorithm</em> and let my <em>subclasses</em> do some of the work.</li>
<li><em>Keep the control</em> over the algorithm&rsquo;s structure and allow be different implementations of individual steps.</li>
<li>Provide method for <em>code reuse</em> allowing <em>subclasses</em> to specify behavior.</li>
<li>Depend on method implemented in the superclass.</li>
</ul>
</li>
<li><strong>Strategy</strong>

<ul>
<li>Define a <em>family of algorithms</em> and make them <em>interchangeable</em>.</li>
<li>Each algorithm is encapsulated so the client can use different algorithms easily.</li>
<li><em>Not use inheritance</em> for algorithm implementations.</li>
<li>Clients use algorithm implementation through <em>object composition</em>.</li>
<li>Clients can change algorithm at <em>runtime</em> by using different <em>strategy object</em>.</li>
<li>Not depend on any superclass.</li>
</ul>
</li>
</ul>


<h2>Template Method in Action</h2>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Observer Pattern]]></title>
    <link href="http://blackat.github.io/blog/2013/03/25/observer-pattern/"/>
    <updated>2013-03-25T23:25:00+01:00</updated>
    <id>http://blackat.github.io/blog/2013/03/25/observer-pattern</id>
    <content type="html"><![CDATA[<blockquote><p>The Observer Pattern defines a one-to-many dependency between objects so that when one object changes state, all of its dependents are notified and updated automatically.</p><footer><strong>Bates and Sierra,</strong> <cite><a href='http://shop.oreilly.com/product/9780596007126.do'>Head First Design Patterns</a></cite></footer></blockquote>


<!-- more -->


<h2>Class diagram</h2>

<p><img src="http://blackat.github.io/images/posts/design-patterns/observer_pattern.png"></p>

<p>Use <code>Subject</code> interface to register or remove an observer. A potential <em>observer</em> must implements the <code>Observer</code> interface, its method will be called when the <em>subject&rsquo;s</em> state changes.</p>

<p>The <code>ConcreteSubject</code> contains and controls the <em>state</em>, it is the sole <em>owner of the data</em>.</p>

<h2>Design Principle</h2>

<p><a href="http://blackat.github.io/oo-design-principles/index.html#loosely_coupled_principle">Loosely Coupled Design Principle.</a></p>

<h2>Scenario</h2>

<p>A news stand produces news during all the day. Each person interested in having news has to subscribe to the stand to get notifications. In this way the person doesn&rsquo;t have to check every time if a new article has been published.</p>

<h2>Key Points</h2>

<ul>
<li><strong>Subject.</strong> It is the observable and updates the observers using a common interface.</li>
<li><strong>Loosely coupled.</strong> Observable doesn&rsquo;t know anything about observers except that they implement an interface.

<ul>
<li>Allow flexible design minimizing the interdependency between objects.</li>
</ul>
</li>
<li><strong>Pull data.</strong> When data changes, observable <em>pull data</em> to the observers.</li>
<li><strong>Order.</strong> There is not any <em>notification order</em>.</li>
<li><strong>Register.</strong> An  observer can register to an observable at any time.</li>
</ul>


<h2>Observer Pattern in Action</h2>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="kd">interface</span> <span class="nc">Subject</span> <span class="o">{</span>
</span><span class='line'>  <span class="kt">void</span> <span class="nf">registerObserver</span><span class="o">(</span><span class="n">Observer</span> <span class="n">observer</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>  <span class="kt">void</span> <span class="nf">removeObserver</span><span class="o">(</span><span class="n">Observer</span> <span class="n">observer</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>  <span class="kt">void</span> <span class="nf">notifyObservers</span><span class="o">();</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>




<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
<span class='line-number'>26</span>
<span class='line-number'>27</span>
<span class='line-number'>28</span>
<span class='line-number'>29</span>
<span class='line-number'>30</span>
<span class='line-number'>31</span>
<span class='line-number'>32</span>
<span class='line-number'>33</span>
<span class='line-number'>34</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kn">import</span> <span class="nn">java.util.ArrayList</span><span class="o">;</span>
</span><span class='line'><span class="kn">import</span> <span class="nn">java.util.List</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">NewsProvider</span> <span class="kd">implements</span> <span class="n">Subject</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>  <span class="kd">private</span> <span class="n">List</span><span class="o">&lt;</span><span class="n">Observer</span><span class="o">&gt;</span> <span class="n">observerList</span><span class="o">;</span>
</span><span class='line'>  <span class="kd">private</span> <span class="n">News</span> <span class="n">news</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>  <span class="kd">public</span> <span class="nf">NewsProvider</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>      <span class="n">observerList</span> <span class="o">=</span> <span class="k">new</span> <span class="n">ArrayList</span><span class="o">&lt;</span><span class="n">Observer</span><span class="o">&gt;();</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>  <span class="nd">@Override</span>
</span><span class='line'>  <span class="kd">public</span> <span class="kt">void</span> <span class="nf">registerObserver</span><span class="o">(</span><span class="n">Observer</span> <span class="n">observer</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>      <span class="n">observerList</span><span class="o">.</span><span class="na">add</span><span class="o">(</span><span class="n">observer</span><span class="o">);</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>  <span class="nd">@Override</span>
</span><span class='line'>  <span class="kd">public</span> <span class="kt">void</span> <span class="nf">removeObserver</span><span class="o">(</span><span class="n">Observer</span> <span class="n">observer</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>      <span class="n">observerList</span><span class="o">.</span><span class="na">remove</span><span class="o">(</span><span class="n">observer</span><span class="o">);</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>  <span class="nd">@Override</span>
</span><span class='line'>  <span class="kd">public</span> <span class="kt">void</span> <span class="nf">notifyObservers</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>      <span class="k">for</span> <span class="o">(</span><span class="n">Observer</span> <span class="n">o</span> <span class="o">:</span> <span class="n">observerList</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>          <span class="n">o</span><span class="o">.</span><span class="na">update</span><span class="o">(</span><span class="n">news</span><span class="o">);</span>
</span><span class='line'>      <span class="o">}</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>  <span class="kt">void</span> <span class="nf">setNews</span><span class="o">(</span><span class="n">News</span> <span class="n">n</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>      <span class="n">news</span> <span class="o">=</span> <span class="n">n</span><span class="o">;</span>
</span><span class='line'>      <span class="n">notifyObservers</span><span class="o">();</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>




<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="kd">interface</span> <span class="nc">Observer</span> <span class="o">{</span>
</span><span class='line'>    <span class="kt">void</span> <span class="nf">update</span><span class="o">(</span><span class="n">News</span> <span class="n">news</span><span class="o">);</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>




<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">NewsObserver</span> <span class="kd">implements</span> <span class="n">Observer</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>  <span class="kd">private</span> <span class="n">Subject</span> <span class="n">subject</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>  <span class="kd">public</span> <span class="nf">NewsObserver</span><span class="o">(</span><span class="n">Subject</span> <span class="n">s</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>      <span class="n">subject</span> <span class="o">=</span> <span class="n">s</span><span class="o">;</span>
</span><span class='line'>      <span class="n">s</span><span class="o">.</span><span class="na">registerObserver</span><span class="o">(</span><span class="k">this</span><span class="o">);</span>
</span><span class='line'>    <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>  <span class="nd">@Override</span>
</span><span class='line'>  <span class="kd">public</span> <span class="kt">void</span> <span class="nf">update</span><span class="o">(</span><span class="n">News</span> <span class="n">news</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>      <span class="n">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="s">&quot;new news published: &quot;</span> <span class="o">+</span> <span class="n">news</span><span class="o">.</span><span class="na">toString</span><span class="o">());</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>




<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">News</span> <span class="o">{</span>
</span><span class='line'>  <span class="kd">private</span> <span class="n">String</span> <span class="n">title</span><span class="o">;</span>
</span><span class='line'>  <span class="kd">private</span> <span class="n">String</span> <span class="n">author</span><span class="o">;</span>
</span><span class='line'>  <span class="kd">private</span> <span class="n">String</span> <span class="n">content</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>  <span class="kd">public</span> <span class="nf">News</span><span class="o">(</span><span class="n">String</span> <span class="n">t</span><span class="o">,</span> <span class="n">String</span> <span class="n">a</span><span class="o">,</span> <span class="n">String</span> <span class="n">c</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>      <span class="n">title</span> <span class="o">=</span> <span class="n">t</span><span class="o">;</span>
</span><span class='line'>      <span class="n">author</span> <span class="o">=</span> <span class="n">a</span><span class="o">;</span>
</span><span class='line'>      <span class="n">content</span> <span class="o">=</span> <span class="n">c</span><span class="o">;</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>  <span class="nd">@Override</span>
</span><span class='line'>  <span class="kd">public</span> <span class="n">String</span> <span class="nf">toString</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>      <span class="k">return</span> <span class="n">title</span> <span class="o">+</span> <span class="s">&quot; &quot;</span> <span class="o">+</span> <span class="n">author</span> <span class="o">+</span> <span class="s">&quot;: &quot;</span> <span class="o">+</span> <span class="n">content</span><span class="o">;</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>




<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">NewsStand</span> <span class="o">{</span>
</span><span class='line'>  <span class="kd">public</span> <span class="kd">static</span> <span class="kt">void</span> <span class="nf">main</span><span class="o">(</span><span class="n">String</span><span class="o">[]</span> <span class="n">args</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>      <span class="n">NewsProvider</span> <span class="n">newsProvider</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">NewsProvider</span><span class="o">();</span>
</span><span class='line'>
</span><span class='line'>      <span class="n">Observer</span> <span class="n">userOne</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">NewsObserver</span><span class="o">(</span><span class="n">newsProvider</span><span class="o">);</span>
</span><span class='line'>      <span class="n">Observer</span> <span class="n">userTwo</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">NewsObserver</span><span class="o">(</span><span class="n">newsProvider</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>      <span class="n">newsProvider</span><span class="o">.</span><span class="na">setNews</span><span class="o">(</span><span class="k">new</span> <span class="nf">News</span><span class="o">(</span><span class="s">&quot;New economy&quot;</span><span class="o">,</span> <span class="s">&quot;Barry Lindon&quot;</span><span class="o">,</span> <span class="s">&quot;Many new changes happened.&quot;</span><span class="o">));</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>

]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Strategy Pattern]]></title>
    <link href="http://blackat.github.io/blog/2013/03/25/strategy-pattern/"/>
    <updated>2013-03-25T20:21:00+01:00</updated>
    <id>http://blackat.github.io/blog/2013/03/25/strategy-pattern</id>
    <content type="html"><![CDATA[<blockquote><p>The Strategy Pattern defines a family of algorithms, encapsulates each one and makes them interchangeable. Strategy lets algorithm vary independently from clients that use it.</p><footer><strong>Bates and Sierra,</strong> <cite><a href='http://shop.oreilly.com/product/9780596007126.do'>Head First Design Patterns</a></cite></footer></blockquote>


<!-- more -->


<h2>Class diagram</h2>

<p><img src="http://blackat.github.io/images/posts/design-patterns/strategy_pattern.png"></p>

<h2>Design Principles</h2>

<p>Some design principle can help in the definition and explanation of the pattern.</p>

<ul>
<li><strong>Encapsulate what varies.</strong>

<ul>
<li>Encapsulating what varies <em>don&rsquo;t affect</em> other parts of the code when changes.</li>
<li>Because of <em>new requirements</em> some <em>aspects</em> of the application could change quite often. <em>Aspects</em> mean <em>behaviors</em> and they have to be separated from <em>aspects</em> that don&rsquo;t change.</li>
<li>Base scheme for all design patterns, they allow some part of the system to <em>vary independently</em> of all other parts.</li>
</ul>
</li>
<li><strong>Program to an interface, not an implementation.</strong>

<ul>
<li>Decouple the code from a specific implementation.</li>
<li>Allow to change the implementation at runtime.</li>
</ul>
</li>
<li><strong>Favor composition over inheritance.</strong>

<ul>
<li>Better to get behaviors by <em>composition</em> than by <em>inheritance</em>.</li>
<li>Composition gives more <em>flexibility</em>.</li>
<li>Encapsulate family of <em>algorithms or behaviors</em> into their own <em>set of classes</em>.</li>
<li>Allow to change behavior at runtime.</li>
</ul>
</li>
</ul>


<h2>Scenario</h2>

<p>A product could update quite frequently because of new requirements introducing new behavior. Considering a simple class inheritance is the first solution that comes to mind.</p>

<p>A class defines some variables to define the state of an instance and methods to implement behaviors. Focus on behaviors.</p>

<ul>
<li>Subclassing allows to inherit <em>behaviors</em> which could change <em>across subclasses</em>.</li>
<li>Overriding <em>behaviors</em> must be done subclass by subclass.</li>
<li><p>Subclass may inherit useless behaviors.</p>

<p>  So how to improve <em>code reuse</em>, avoid <em>code duplication</em> and make simple the design?</p></li>
</ul>


<h2>Design Principles in Action</h2>

<p>To better design the application apply the design principles explained so far.</p>

<ul>
<li><strong>Encapsulate what varies.</strong>

<ul>
<li>Create one or more <em>set of classes</em> to encapsulate the <em>implementation</em> of their respective <em>behaviors</em>.</li>
<li>Behaviors encapsulated into classes can be <em>reused</em>.</li>
<li>Encapsulation means put a given implementation in a separated class.</li>
<li>Separation and encapsulation allow <em>composition</em>, so <em>behaviors are assigned to instances</em>.</li>
</ul>
</li>
<li><strong>Program to an interface.</strong>

<ul>
<li>Implementation can be defined at runtime, no more specific implementation.</li>
<li>Interfaces are a set of behaviors, some classes exist <em>only to implement a behavior</em>.</li>
<li><strong>Inheritance.</strong> Synonym of <em>concrete implementation</em>. An <em>inherited behavior</em> means concrete implementation from the superclass or the subclass providing a specialized implementation of the behavior.</li>
<li><strong>Interface.</strong> Synonym of a <em>set of behaviors</em>.

<ul>
<li><strong>Program to an abstract supertype.</strong> Program to an interface or abstract class.</li>
<li><strong>Polymorphism.</strong> The <em>runtime object</em> or <em>actual implementation of the behavior</em> is not locked into the client class.</li>
</ul>
</li>
</ul>
</li>
<li><strong>Favorite composition.</strong>

<ul>
<li><strong>HAS-A relation.</strong>

<ul>
<li>It means <em>delegation</em>, a class <em>delegate its behavior</em> to other classes instead of defining them by itself, IS-A.</li>
<li>It is better than IS-A because it avoids to lock the client to a specific implementation and change behaviors at runtime using interfaces.</li>
<li>Behaviors can be <em>changed</em> without affecting the clients, new behaviors can be added without touching the existing ones.</li>
<li>Behaviors can be <em>reused</em> by multiple clients.</li>
</ul>
</li>
</ul>
</li>
</ul>


<h2>Set Behavior Implementation</h2>

<p>The behavior implementation can be set via</p>

<ul>
<li><strong>constructor:</strong> once the class is created the behavior class is set,</li>
<li><strong>setter method:</strong> call the setter any time to change the class behavior on the fly,</li>
<li><strong>mixed:</strong> use the constructor to set a default behavior and the setter to change it at runtime,</li>
<li><strong>subclass:</strong> can define a new constructor.</li>
</ul>


<p><em>Set of behaviors</em> can be seen as a <strong>family of algorithms</strong>.</p>

<h2>Example</h2>

<p><img src="http://blackat.github.io/images/posts/design-patterns/behavior_interface.png"></p>

<p>Composition is realized by defining an interface type variable and then delegating to different set of classes the implementation of the behaviors.</p>

<p><img src="http://blackat.github.io/images/posts/design-patterns/person_class.png"></p>

<p>Behaviors defined by composition are implemented by external classes which exist only for this purpose, so they can change, extended and added without affecting <code>Person</code> class.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Protection Proxy]]></title>
    <link href="http://blackat.github.io/blog/2013/03/22/protection-proxy-pattern/"/>
    <updated>2013-03-22T19:38:00+01:00</updated>
    <id>http://blackat.github.io/blog/2013/03/22/protection-proxy-pattern</id>
    <content type="html"><![CDATA[<blockquote><p>It controls the access to a resource based on access rights.</p></blockquote>


<!-- more -->


<p><strong>Scenario.</strong> A proxy <em>controls the access</em> to the real object applying <em>protection</em> to the method calls in a transparent way. The client will invoke methods against the proxy thinking it is the real object.</p>

<p><strong>Java dynamic proxy support.</strong> <code>java.lang.reflect</code> package can be used to create a proxy class <em>on the fly</em>. The <em>proxy class</em> implements one or more interfaces and delegates method invocation to a  specified class, the <em>invoker handler</em>.</p>

<p><strong>Class diagram.</strong> The use of <code>java.lang.reflect</code> package imposes a change in the proxy pattern class diagram.
<img src="http://blackat.github.io/images/posts/design-patterns/protection_proxy.jpg"></p>

<p><strong>Proxy in action.</strong> The handler answers to any method call made by the client on the proxy. The proxy implements <em>the same interface</em> as the real object.</p>

<h2>Example</h2>

<p>A reviewer can only get information about a movie and write comments, he cannot change the title or the actors of the movie.</p>

<h3>Start</h3>

<p>The <code>MovieReviews</code> class simply creates a of two movie proxies, each proxy manages one movie.
Using the <em>static method</em> <code>Proxy.newProxyInstance(Movie.class.getClassLoader(), new Class[]{Movie.class}, forrestGumpHandler);</code> allows the creation of a new proxy <em>on the fly</em> passing:</p>

<ul>
<li>the same class loader of the <code>Movie</code> interface or of the <em>real movie object</em>,</li>
<li>the interface the proxy has to expose,</li>
<li>the handler every method call has to be delegated to, it also <em>wraps</em> the <em>real object</em>.</li>
</ul>


<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
<span class='line-number'>26</span>
<span class='line-number'>27</span>
<span class='line-number'>28</span>
<span class='line-number'>29</span>
<span class='line-number'>30</span>
<span class='line-number'>31</span>
<span class='line-number'>32</span>
<span class='line-number'>33</span>
<span class='line-number'>34</span>
<span class='line-number'>35</span>
<span class='line-number'>36</span>
<span class='line-number'>37</span>
<span class='line-number'>38</span>
<span class='line-number'>39</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kn">import</span> <span class="nn">java.lang.reflect.InvocationHandler</span><span class="o">;</span>
</span><span class='line'><span class="kn">import</span> <span class="nn">java.lang.reflect.Proxy</span><span class="o">;</span>
</span><span class='line'><span class="kn">import</span> <span class="nn">java.util.ArrayList</span><span class="o">;</span>
</span><span class='line'><span class="kn">import</span> <span class="nn">java.util.List</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">MovieReviews</span> <span class="o">{</span>
</span><span class='line'>  <span class="kd">public</span> <span class="kd">static</span> <span class="kt">void</span> <span class="nf">main</span><span class="o">(</span><span class="n">String</span><span class="o">[]</span> <span class="n">args</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>      <span class="k">new</span> <span class="nf">MovieReviews</span><span class="o">().</span><span class="na">run</span><span class="o">();</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>  <span class="kd">public</span> <span class="kt">void</span> <span class="nf">run</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>      <span class="n">Reviewer</span> <span class="n">reviewer</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">Reviewer</span><span class="o">(</span><span class="n">buildMovieList</span><span class="o">());</span>
</span><span class='line'>      <span class="k">try</span> <span class="o">{</span>
</span><span class='line'>          <span class="n">reviewer</span><span class="o">.</span><span class="na">spoilMovieTitle</span><span class="o">();</span>
</span><span class='line'>      <span class="o">}</span> <span class="k">catch</span> <span class="o">(</span><span class="n">Exception</span> <span class="n">e</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>          <span class="n">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="s">&quot;operation not permitted.&quot;</span><span class="o">);</span>
</span><span class='line'>      <span class="o">}</span>
</span><span class='line'>      <span class="n">reviewer</span><span class="o">.</span><span class="na">printMovieTiles</span><span class="o">();</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>  <span class="kd">public</span> <span class="n">List</span><span class="o">&lt;</span><span class="n">Movie</span><span class="o">&gt;</span> <span class="nf">buildMovieList</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>      <span class="n">List</span><span class="o">&lt;</span><span class="n">Movie</span><span class="o">&gt;</span> <span class="n">movieList</span> <span class="o">=</span> <span class="k">new</span> <span class="n">ArrayList</span><span class="o">&lt;</span><span class="n">Movie</span><span class="o">&gt;();</span>
</span><span class='line'>
</span><span class='line'>      <span class="n">Movie</span> <span class="n">forrestGumpMovie</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">MovieImpl</span><span class="o">(</span><span class="s">&quot;Forrest Gump&quot;</span><span class="o">,</span> <span class="s">&quot;Tom Hanks&quot;</span><span class="o">,</span> <span class="s">&quot;Gary Sinise&quot;</span><span class="o">,</span> <span class="s">&quot;Robin Wright&quot;</span><span class="o">);</span>
</span><span class='line'>      <span class="n">InvocationHandler</span> <span class="n">forrestGumpHandler</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">InvocationHandlerImpl</span><span class="o">(</span><span class="n">forrestGumpMovie</span><span class="o">);</span>
</span><span class='line'>      <span class="n">Movie</span> <span class="n">forrestGumpProxy</span> <span class="o">=</span> <span class="o">(</span><span class="n">Movie</span><span class="o">)</span> <span class="n">Proxy</span><span class="o">.</span><span class="na">newProxyInstance</span><span class="o">(</span><span class="n">Movie</span><span class="o">.</span><span class="na">class</span><span class="o">.</span><span class="na">getClassLoader</span><span class="o">(),</span>
</span><span class='line'>          <span class="k">new</span> <span class="n">Class</span><span class="o">[]{</span><span class="n">Movie</span><span class="o">.</span><span class="na">class</span><span class="o">},</span> <span class="n">forrestGumpHandler</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>      <span class="n">Movie</span> <span class="n">djangoMovie</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">MovieImpl</span><span class="o">(</span><span class="s">&quot;Django&quot;</span><span class="o">,</span> <span class="s">&quot;Quentin Tarantino&quot;</span><span class="o">,</span> <span class="s">&quot;Jamie Foxx&quot;</span><span class="o">,</span> <span class="s">&quot;Franco Nero&quot;</span><span class="o">);</span>
</span><span class='line'>      <span class="n">InvocationHandler</span> <span class="n">djangoHandler</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">InvocationHandlerImpl</span><span class="o">(</span><span class="n">djangoMovie</span><span class="o">);</span>
</span><span class='line'>      <span class="n">Movie</span> <span class="n">djangoProxy</span> <span class="o">=</span> <span class="o">(</span><span class="n">Movie</span><span class="o">)</span> <span class="n">Proxy</span><span class="o">.</span><span class="na">newProxyInstance</span><span class="o">(</span><span class="n">Movie</span><span class="o">.</span><span class="na">class</span><span class="o">.</span><span class="na">getClassLoader</span><span class="o">(),</span>
</span><span class='line'>          <span class="k">new</span> <span class="n">Class</span><span class="o">[]{</span><span class="n">Movie</span><span class="o">.</span><span class="na">class</span><span class="o">},</span> <span class="n">djangoHandler</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>      <span class="n">movieList</span><span class="o">.</span><span class="na">add</span><span class="o">(</span><span class="n">forrestGumpProxy</span><span class="o">);</span>
</span><span class='line'>      <span class="n">movieList</span><span class="o">.</span><span class="na">add</span><span class="o">(</span><span class="n">djangoProxy</span><span class="o">);</span>
</span><span class='line'>
</span><span class='line'>      <span class="k">return</span> <span class="n">movieList</span><span class="o">;</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<h3>The Interface</h3>

<p>Very simple interface with some getters, setters and the method to comment the movie.</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kn">import</span> <span class="nn">java.util.List</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'><span class="kd">public</span> <span class="kd">interface</span> <span class="nc">Movie</span> <span class="o">{</span>
</span><span class='line'>  <span class="n">String</span> <span class="nf">getTitle</span><span class="o">();</span>
</span><span class='line'>  <span class="kt">void</span> <span class="nf">setTitle</span><span class="o">(</span><span class="n">String</span> <span class="n">title</span><span class="o">);</span>
</span><span class='line'>  <span class="n">List</span><span class="o">&lt;</span><span class="n">String</span><span class="o">&gt;</span> <span class="nf">getActors</span><span class="o">();</span>
</span><span class='line'>  <span class="kt">void</span> <span class="nf">setActors</span><span class="o">(</span><span class="n">List</span><span class="o">&lt;</span><span class="n">String</span><span class="o">&gt;</span> <span class="n">actors</span><span class="o">);</span>
</span><span class='line'>  <span class="kt">void</span> <span class="nf">comment</span><span class="o">(</span><span class="n">String</span> <span class="n">comment</span><span class="o">);</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<h3>The Invocation Handler</h3>

<p>This class will invoke the method, by using <em>reflection</em>, on the <em>real object</em> that is <em>wrapped</em>. The proxy object will create at runtime, so the handler is the only place where the protection logic can be put.</p>

<p>The protection disallow to use any <code>setter</code> method, only <code>getters</code> and <code>comment</code> methods can be invoked.</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
<span class='line-number'>26</span>
<span class='line-number'>27</span>
<span class='line-number'>28</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kn">import</span> <span class="nn">java.lang.reflect.InvocationHandler</span><span class="o">;</span>
</span><span class='line'><span class="kn">import</span> <span class="nn">java.lang.reflect.InvocationTargetException</span><span class="o">;</span>
</span><span class='line'><span class="kn">import</span> <span class="nn">java.lang.reflect.Method</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">InvocationHandlerImpl</span> <span class="kd">implements</span> <span class="n">InvocationHandler</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>  <span class="kd">private</span> <span class="n">Movie</span> <span class="n">movie</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>  <span class="kd">public</span> <span class="nf">InvocationHandlerImpl</span><span class="o">(</span><span class="n">Movie</span> <span class="n">c</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>      <span class="n">movie</span> <span class="o">=</span> <span class="n">c</span><span class="o">;</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>  <span class="nd">@Override</span>
</span><span class='line'>  <span class="kd">public</span> <span class="n">Object</span> <span class="nf">invoke</span><span class="o">(</span><span class="n">Object</span> <span class="n">proxy</span><span class="o">,</span> <span class="n">Method</span> <span class="n">method</span><span class="o">,</span> <span class="n">Object</span><span class="o">[]</span> <span class="n">args</span><span class="o">)</span> <span class="kd">throws</span> <span class="n">Throwable</span> <span class="o">{</span>
</span><span class='line'>      <span class="k">try</span> <span class="o">{</span>
</span><span class='line'>          <span class="k">if</span> <span class="o">(</span><span class="n">method</span><span class="o">.</span><span class="na">getName</span><span class="o">().</span><span class="na">startsWith</span><span class="o">(</span><span class="s">&quot;set&quot;</span><span class="o">))</span> <span class="o">{</span>
</span><span class='line'>              <span class="k">throw</span> <span class="k">new</span> <span class="nf">IllegalAccessException</span><span class="o">();</span>
</span><span class='line'>          <span class="o">}</span> <span class="k">else</span> <span class="nf">if</span> <span class="o">(</span><span class="n">method</span><span class="o">.</span><span class="na">getName</span><span class="o">().</span><span class="na">equals</span><span class="o">(</span><span class="s">&quot;comment&quot;</span><span class="o">))</span> <span class="o">{</span>
</span><span class='line'>              <span class="k">return</span> <span class="n">method</span><span class="o">.</span><span class="na">invoke</span><span class="o">(</span><span class="n">movie</span><span class="o">,</span> <span class="n">args</span><span class="o">);</span>
</span><span class='line'>          <span class="o">}</span> <span class="k">else</span> <span class="nf">if</span> <span class="o">(</span><span class="n">method</span><span class="o">.</span><span class="na">getName</span><span class="o">().</span><span class="na">startsWith</span><span class="o">(</span><span class="s">&quot;get&quot;</span><span class="o">))</span> <span class="o">{</span>
</span><span class='line'>              <span class="k">return</span> <span class="n">method</span><span class="o">.</span><span class="na">invoke</span><span class="o">(</span><span class="n">movie</span><span class="o">,</span> <span class="n">args</span><span class="o">);</span>
</span><span class='line'>          <span class="o">}</span>
</span><span class='line'>      <span class="o">}</span> <span class="k">catch</span> <span class="o">(</span><span class="n">InvocationTargetException</span> <span class="n">e</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>          <span class="n">e</span><span class="o">.</span><span class="na">printStackTrace</span><span class="o">();</span>
</span><span class='line'>      <span class="o">}</span>
</span><span class='line'>      <span class="k">return</span> <span class="kc">null</span><span class="o">;</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<h3>The Client</h3>

<p>The client will receive the list of the movies which he can write a comment on. From the reviewer point of view every object exposes the <code>Movie</code> interface, so he doesn&rsquo;t know to invoke methods against a proxy object.</p>

<p>Remember, both the proxy and the real movie object implement the <em>same interface</em> so the proxy can <em>take the place</em> of the <em>real object</em>.</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kn">import</span> <span class="nn">java.util.List</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">Reviewer</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>  <span class="n">List</span><span class="o">&lt;</span><span class="n">Movie</span><span class="o">&gt;</span> <span class="n">movieList</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>  <span class="kd">public</span> <span class="nf">Reviewer</span><span class="o">(</span><span class="n">List</span><span class="o">&lt;</span><span class="n">Movie</span><span class="o">&gt;</span> <span class="n">list</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>      <span class="n">movieList</span> <span class="o">=</span> <span class="n">list</span><span class="o">;</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>  <span class="kd">public</span> <span class="kt">void</span> <span class="nf">spoilMovieTitle</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>      <span class="k">for</span> <span class="o">(</span><span class="n">Movie</span> <span class="n">movie</span> <span class="o">:</span> <span class="n">movieList</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>          <span class="n">movie</span><span class="o">.</span><span class="na">setTitle</span><span class="o">(</span><span class="s">&quot;spoiled&quot;</span><span class="o">);</span>
</span><span class='line'>      <span class="o">}</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>  <span class="kd">public</span> <span class="kt">void</span> <span class="nf">printMovieTiles</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>      <span class="k">for</span> <span class="o">(</span><span class="n">Movie</span> <span class="n">movie</span> <span class="o">:</span> <span class="n">movieList</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>          <span class="n">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="n">movie</span><span class="o">.</span><span class="na">getTitle</span><span class="o">());</span>
</span><span class='line'>      <span class="o">}</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>

]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Remote Proxy]]></title>
    <link href="http://blackat.github.io/blog/2013/03/22/remote-proxy-pattern/"/>
    <updated>2013-03-22T19:36:00+01:00</updated>
    <id>http://blackat.github.io/blog/2013/03/22/remote-proxy-pattern</id>
    <content type="html"><![CDATA[<blockquote><p>The proxy acts as a _local representative_ for an object that lives somewhere else on the network on a different JVM.</p></blockquote>


<!-- more -->


<p><strong>Scenario.</strong> The client uses a service invoking some methods. Actually the service is located on a remote machine but the location the service should be transparent respect to the client.</p>

<p><strong>Remote proxy.</strong> It behaves as a <em>local representative</em> for an remote object living on a <em>different JVM</em>.</p>

<p><strong>Method call.</strong> A method call against the proxy results in the <em>transfer of the call</em> over the wire to the remote JVM. Once there the method call is invoked against the real object. The result of the call is returned back to the <em>proxy</em>, then from the proxy to the <em>client</em>.</p>

<h2>RMI</h2>

<p>Java Remote Method Invocation (RMI) is an example of remote proxy. RMI build two <em>helper objects</em>, <em>stub</em> and <em>skeleton</em>, which <em>hide</em> the communication and technical details about the transfer of the method call and the result return. The client will just interact with the proxy, one of the two helper objects.</p>

<p><strong>RMI vs. Remote proxy</strong> Remote proxy does not involve any helper object as RMI does, but just the proxy concept.</p>

<h2>Example</h2>

<p>A very simple example consists of a client that uses a service to get something done. The client is unaware of the service location and type. The client does not know if the service is remote or local, if it will do database or disk access to provide data.</p>

<p>There are <em>five steps</em> to implement a <em>remote service</em> based on RMI.</p>

<h3>Remote Service Interface</h3>

<p>Define the <em>interface</em> the client will use to interact with the service.</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kn">import</span> <span class="nn">java.rmi.Remote</span><span class="o">;</span>
</span><span class='line'><span class="kn">import</span> <span class="nn">java.rmi.RemoteException</span><span class="o">;</span>
</span><span class='line'><span class="kn">import</span> <span class="nn">java.util.List</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'><span class="kd">public</span> <span class="kd">interface</span> <span class="nc">ContactService</span> <span class="kd">extends</span> <span class="n">Remote</span> <span class="o">{</span>
</span><span class='line'>  <span class="n">List</span><span class="o">&lt;</span><span class="n">String</span><span class="o">&gt;</span> <span class="nf">listAll</span><span class="o">()</span> <span class="kd">throws</span> <span class="n">RemoteException</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>  <span class="kt">int</span> <span class="nf">getContactSize</span><span class="o">()</span> <span class="kd">throws</span> <span class="n">RemoteException</span><span class="o">;</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p><strong>Remote interface.</strong> <code>java.rmi.Remote</code> is just a <em>marker</em> that is an interface without methods. The marker tells that the interface will be used to support <em>remote calls</em>.</p>

<p><strong>Client.</strong> It uses a service of type <code>ContactService</code>, the <em>remote service interface</em>, to invoke methods without knowing any implementation detail and thinking it is the real object.</p>

<p><strong>Proxy.</strong> It implements the <em>remote interface</em> as the real object does, so the proxy can be used as a <em>surrogate</em> of the real object or, better, the proxy <em>substitute</em> the real object for all the request.</p>

<p><strong>Stub.</strong> In RMI the proxy is called <em>stub</em>. It will manage all the networking and I/O operations. Something could go wrong (ex. network failure) so every remote method call is <em>risky</em> and has to declare to throw a <code>java.rmi.RemoteException</code> to handle possible communication failures.</p>

<p><strong>Arguments and return values.</strong> They must be <code>primitive</code> or <code>Serializable</code>. Serialization is used to package values and transfer them across the network. In the example above, all the types implement natively <code>Serializable</code> interface as many other types from Java API.</p>

<h3>Remote Service Implementation</h3>

<p>The implementation of the service is very simple, this is the <em>real object</em> where the calls will be invoked on. The service will reside on the server machine.</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kn">import</span> <span class="nn">java.rmi.RemoteException</span><span class="o">;</span>
</span><span class='line'><span class="kn">import</span> <span class="nn">java.rmi.server.UnicastRemoteObject</span><span class="o">;</span>
</span><span class='line'><span class="kn">import</span> <span class="nn">java.util.ArrayList</span><span class="o">;</span>
</span><span class='line'><span class="kn">import</span> <span class="nn">java.util.List</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">ContactServiceImpl</span> <span class="kd">extends</span> <span class="n">UnicastRemoteObject</span> <span class="kd">implements</span> <span class="n">ContactService</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>  <span class="kd">protected</span> <span class="nf">ContactServiceImpl</span><span class="o">()</span> <span class="kd">throws</span> <span class="n">RemoteException</span> <span class="o">{</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>  <span class="nd">@Override</span>
</span><span class='line'>  <span class="kd">public</span> <span class="n">List</span><span class="o">&lt;</span><span class="n">String</span><span class="o">&gt;</span> <span class="nf">listAll</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>      <span class="n">List</span><span class="o">&lt;</span><span class="n">String</span><span class="o">&gt;</span> <span class="n">contacts</span> <span class="o">=</span> <span class="k">new</span> <span class="n">ArrayList</span><span class="o">&lt;</span><span class="n">String</span><span class="o">&gt;();</span>
</span><span class='line'>      <span class="n">contacts</span><span class="o">.</span><span class="na">add</span><span class="o">(</span><span class="s">&quot;Fermi&quot;</span><span class="o">);</span>
</span><span class='line'>      <span class="n">contacts</span><span class="o">.</span><span class="na">add</span><span class="o">(</span><span class="s">&quot;Majorana&quot;</span><span class="o">);</span>
</span><span class='line'>      <span class="k">return</span> <span class="n">contacts</span><span class="o">;</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>  <span class="nd">@Override</span>
</span><span class='line'>  <span class="kd">public</span> <span class="kt">int</span> <span class="nf">getContactSize</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>      <span class="k">return</span> <span class="mi">18</span><span class="o">;</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p><strong>Being remote.</strong> Service implementation must extends <code>java.rmi.server.UnicastRemoteObject</code> to make it <em>remote</em> and so working as a <em>remote service object</em>. This class has some functionality (ex. read and write values on the socket) that allow it to <em>be remote</em>.</p>

<p><strong>Superclass constructor.</strong> Superclass <code>UnicastRemoteObject</code> <em>constructor</em> throws a <code>RemoteException</code>. Superclass constructor is always called so no choice but declare that a constructor throws an exception.</p>

<p><strong>Remote service registration.</strong> The <em>remote service implementation</em> needs be registered in the registry to make it available to remote clients. The registration is done by the <code>Server</code> class.</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kn">import</span> <span class="nn">java.net.MalformedURLException</span><span class="o">;</span>
</span><span class='line'><span class="kn">import</span> <span class="nn">java.rmi.Naming</span><span class="o">;</span>
</span><span class='line'><span class="kn">import</span> <span class="nn">java.rmi.RemoteException</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">Server</span> <span class="o">{</span>
</span><span class='line'>  <span class="kd">public</span> <span class="kd">static</span> <span class="kt">void</span> <span class="nf">main</span><span class="o">(</span><span class="kd">final</span> <span class="n">String</span><span class="o">[]</span> <span class="n">args</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>      <span class="k">try</span> <span class="o">{</span>
</span><span class='line'>          <span class="n">ContactService</span> <span class="n">contactService</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">ContactServiceImpl</span><span class="o">();</span>
</span><span class='line'>          <span class="n">Naming</span><span class="o">.</span><span class="na">rebind</span><span class="o">(</span><span class="s">&quot;/contact_service&quot;</span><span class="o">,</span> <span class="n">contactService</span><span class="o">);</span>
</span><span class='line'>      <span class="o">}</span> <span class="k">catch</span> <span class="o">(</span><span class="n">MalformedURLException</span> <span class="n">e</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>          <span class="n">e</span><span class="o">.</span><span class="na">printStackTrace</span><span class="o">();</span>
</span><span class='line'>      <span class="o">}</span> <span class="k">catch</span> <span class="o">(</span><span class="n">RemoteException</span> <span class="n">e</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>          <span class="n">e</span><span class="o">.</span><span class="na">printStackTrace</span><span class="o">();</span>
</span><span class='line'>      <span class="o">}</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p><strong>RMI registry.</strong> Statement <code>Naming.rebind("/service", service)</code> puts the remote service <em>implementation</em> into the RMI registry with a <em>service name</em>. The client will use this name in order to look up for the <em>stub</em>.</p>

<p><strong>Stub.</strong> The server registers or puts the <em>stub</em> in the <em>registry</em>.</p>

<h3>Generate Stub and Skeleton</h3>

<p>They are the client and server <em>helpers</em> created automatically by <code>rmic</code>. These classes implements all the code necessary to manage the connection socket and transfer the method call to the real object residing on the remote JVM.</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
</pre></td><td class='code'><pre><code class='bat'><span class='line'>MacBook:remote blackcat$ rmic ContactServiceImpl
</span></code></pre></td></tr></table></div></figure>


<p><strong>Stub and skeleton.</strong> Invoking <code>rmic</code> on <em>service implementation</em> generates <code>ContactServiceImpl_Stub.class</code> and <code>ContactServiceImpl_Skeleton.class</code>, the two helper objects. They will manage the transfer over the wire of the request about the method call which, finally, will be executed against the real object, <code>ContactServiceImpl</code>.</p>

<h3>Start the Registry</h3>

<p>The <code>rmiregistry</code> is a sort of white pages  where services can be registered and looked up. The client will look for the <em>proxy</em> or <em>client helper</em> or <em>stub</em> into the register. <em>Classes must be available to the rmi registry.</em></p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
</pre></td><td class='code'><pre><code class='bat'><span class='line'>MacBook:remote blackcat$ rmiregistry &amp;
</span></code></pre></td></tr></table></div></figure>


<h3>Start the Server</h3>

<p>Once the registry has been started, it is possible to run the server which will register the service implementation.</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
</pre></td><td class='code'><pre><code class='bat'><span class='line'>MacBook:remote blackcat$ java Server
</span></code></pre></td></tr></table></div></figure>


<h3>The Client</h3>

<p>The client looks up the service, gets the reference to the <em>stub</em> and invokes the method against it.</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
<span class='line-number'>26</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kn">import</span> <span class="nn">java.net.MalformedURLException</span><span class="o">;</span>
</span><span class='line'><span class="kn">import</span> <span class="nn">java.rmi.Naming</span><span class="o">;</span>
</span><span class='line'><span class="kn">import</span> <span class="nn">java.rmi.NotBoundException</span><span class="o">;</span>
</span><span class='line'><span class="kn">import</span> <span class="nn">java.rmi.RemoteException</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">Client</span> <span class="o">{</span>
</span><span class='line'>  <span class="kd">public</span> <span class="kd">static</span> <span class="kt">void</span> <span class="nf">main</span><span class="o">(</span><span class="kd">final</span> <span class="n">String</span><span class="o">[]</span> <span class="n">args</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>      <span class="k">new</span> <span class="nf">Client</span><span class="o">().</span><span class="na">start</span><span class="o">();</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>  <span class="kd">public</span> <span class="kt">void</span> <span class="nf">start</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>      <span class="k">try</span> <span class="o">{</span>
</span><span class='line'>          <span class="n">ContactService</span> <span class="n">contactService</span> <span class="o">=</span> <span class="o">(</span><span class="n">ContactService</span><span class="o">)</span> <span class="n">Naming</span><span class="o">.</span><span class="na">lookup</span><span class="o">(</span><span class="s">&quot;rmi://127.0.0.1/contact_service&quot;</span><span class="o">);</span>
</span><span class='line'>          <span class="n">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="s">&quot;number of contacts in the address book is: &quot;</span> <span class="o">+</span> <span class="n">contactService</span><span class="o">.</span><span class="na">getContactSize</span><span class="o">());</span>
</span><span class='line'>          <span class="k">for</span> <span class="o">(</span><span class="n">String</span> <span class="n">contact</span> <span class="o">:</span> <span class="n">contactService</span><span class="o">.</span><span class="na">listAll</span><span class="o">())</span> <span class="o">{</span>
</span><span class='line'>              <span class="n">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="n">contact</span><span class="o">);</span>
</span><span class='line'>          <span class="o">}</span>
</span><span class='line'>      <span class="o">}</span> <span class="k">catch</span> <span class="o">(</span><span class="n">NotBoundException</span> <span class="n">e</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>          <span class="n">e</span><span class="o">.</span><span class="na">printStackTrace</span><span class="o">();</span>
</span><span class='line'>      <span class="o">}</span> <span class="k">catch</span> <span class="o">(</span><span class="n">MalformedURLException</span> <span class="n">e</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>          <span class="n">e</span><span class="o">.</span><span class="na">printStackTrace</span><span class="o">();</span>
</span><span class='line'>      <span class="o">}</span> <span class="k">catch</span> <span class="o">(</span><span class="n">RemoteException</span> <span class="n">e</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>          <span class="n">e</span><span class="o">.</span><span class="na">printStackTrace</span><span class="o">();</span>
</span><span class='line'>      <span class="o">}</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<p><strong>Naming lookup.</strong> Static method <code>Naming.lookup("rmi://127.0.0.1/contact_service")</code> allows the client to get the reference to an instance which represents the <em>helper</em> or <em>stub</em>.</p>

<p><strong>Remote interface.</strong> The client uses the remote interface as service type without knowing the real <em>class name</em> of the remote service.</p>

<p><strong>Cast.</strong> The <code>lookup</code> method returns an instance of type <code>Object</code> which has to be casted to the remote service type.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Virtual Proxy]]></title>
    <link href="http://blackat.github.io/blog/2013/03/22/virtual-proxy-pattern/"/>
    <updated>2013-03-22T19:35:00+01:00</updated>
    <id>http://blackat.github.io/blog/2013/03/22/virtual-proxy-pattern</id>
    <content type="html"><![CDATA[<blockquote><p>It controls the access to a resource that is expensive to create, for instance data for object creation have to be retrieved from a network.</p></blockquote>


<!-- more -->


<p><strong>Scenario.</strong> The client has to interact with an object which is very expensive to create.</p>

<p><strong>Virtual proxy.</strong> The proxy hides the complexity of creating an managing the real subject. Moreover the proxy could <em>handle the request by itself</em> or <em>creates the expensive object</em> and directly delegate to it the request.</p>

<p><strong>Proxy in action.</strong> The proxy acts as a <em>surrogate</em> for the real object before and while it is created.</p>

<h2>Example</h2>

<p>Each contact of an address book has some details such as the name, surname, address and a picture. The picture should always be up to date, for this reason must be retrieved from the network or from a database. The creation of the picture is expensive involving a connection.</p>

<p>The proxy will control how the picture is retrieved without blocking the main application.</p>

<p><img src="http://blackat.github.io/images/posts/design-patterns/virtual_proxy_example.png"></p>

<p>Implementing the same interface, <code>Picture</code>, <code>ProxyPicture</code> can be used in place of <code>ContactPicture</code> so the client will use an instance reference of type <code>Picture</code> without knowing that it is a proxy.</p>

<h3>Start</h3>

<p>When the system starts will create a proxy which will be passed to the client, the <code>Contact</code> class. Calling <code>toString()</code> method the first time will start the retrieval process.</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">AddressBook</span> <span class="o">{</span>
</span><span class='line'>  <span class="kd">public</span> <span class="kd">static</span> <span class="kt">void</span> <span class="nf">main</span><span class="o">(</span><span class="n">String</span><span class="o">[]</span> <span class="n">args</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>      <span class="k">new</span> <span class="nf">AddressBook</span><span class="o">().</span><span class="na">run</span><span class="o">();</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>  <span class="kd">public</span> <span class="kt">void</span> <span class="nf">run</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>      <span class="n">NetworkService</span> <span class="n">ns</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">NetworkServiceImpl</span><span class="o">();</span>
</span><span class='line'>      <span class="n">Contact</span> <span class="n">contact</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">Contact</span><span class="o">(</span><span class="k">new</span> <span class="nf">PictureProxy</span><span class="o">(</span><span class="n">ns</span><span class="o">));</span>
</span><span class='line'>      <span class="n">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="n">contact</span><span class="o">.</span><span class="na">toString</span><span class="o">());</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<h3>The Client</h3>

<p>It gets a reference of type <code>Picture</code> thinking to be the real object, but it is the proxy.</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">Contact</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>  <span class="kd">private</span> <span class="n">Picture</span> <span class="n">picture</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>  <span class="kd">public</span> <span class="nf">Contact</span><span class="o">(</span><span class="n">Picture</span> <span class="n">p</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>      <span class="n">picture</span> <span class="o">=</span> <span class="n">p</span><span class="o">;</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>  <span class="nd">@Override</span>
</span><span class='line'>  <span class="kd">public</span> <span class="n">String</span> <span class="nf">toString</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>      <span class="k">if</span> <span class="o">(</span><span class="n">picture</span><span class="o">.</span><span class="na">getName</span><span class="o">()</span> <span class="o">==</span> <span class="kc">null</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>          <span class="k">return</span> <span class="s">&quot;picture is going to be retrieved...&quot;</span><span class="o">;</span>
</span><span class='line'>      <span class="o">}</span> <span class="k">else</span> <span class="o">{</span>
</span><span class='line'>          <span class="k">return</span> <span class="n">picture</span><span class="o">.</span><span class="na">getFormat</span><span class="o">()</span> <span class="o">+</span> <span class="s">&quot; &quot;</span> <span class="o">+</span> <span class="n">picture</span><span class="o">.</span><span class="na">getName</span><span class="o">()</span> <span class="o">+</span> <span class="s">&quot; &quot;</span> <span class="o">+</span> <span class="k">new</span> <span class="nf">String</span><span class="o">(</span><span class="n">picture</span><span class="o">.</span><span class="na">getImage</span><span class="o">());</span>
</span><span class='line'>      <span class="o">}</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>


<h3>The Proxy</h3>

<p>It <strong><em>wraps</em></strong> the <em>real object</em>. At the first method call, the proxy will start a thread to retrieve the data and return a <code>null</code> value until data are not available then it <strong><em>builds</em></strong> the real object it wraps. Once the proxy will have the data it will <em>directly answer</em> to the client.</p>

<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
<span class='line-number'>26</span>
<span class='line-number'>27</span>
<span class='line-number'>28</span>
<span class='line-number'>29</span>
<span class='line-number'>30</span>
<span class='line-number'>31</span>
<span class='line-number'>32</span>
<span class='line-number'>33</span>
<span class='line-number'>34</span>
<span class='line-number'>35</span>
<span class='line-number'>36</span>
<span class='line-number'>37</span>
<span class='line-number'>38</span>
<span class='line-number'>39</span>
<span class='line-number'>40</span>
<span class='line-number'>41</span>
<span class='line-number'>42</span>
<span class='line-number'>43</span>
<span class='line-number'>44</span>
<span class='line-number'>45</span>
<span class='line-number'>46</span>
<span class='line-number'>47</span>
<span class='line-number'>48</span>
<span class='line-number'>49</span>
<span class='line-number'>50</span>
<span class='line-number'>51</span>
<span class='line-number'>52</span>
</pre></td><td class='code'><pre><code class='java'><span class='line'><span class="kn">import</span> <span class="nn">java.net.MalformedURLException</span><span class="o">;</span>
</span><span class='line'><span class="kn">import</span> <span class="nn">java.net.URL</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'><span class="kd">public</span> <span class="kd">class</span> <span class="nc">PictureProxy</span> <span class="kd">implements</span> <span class="n">Picture</span> <span class="o">{</span>
</span><span class='line'>
</span><span class='line'>  <span class="kd">private</span> <span class="n">ContactPicture</span> <span class="n">contactPicture</span><span class="o">;</span>
</span><span class='line'>  <span class="kd">private</span> <span class="kt">boolean</span> <span class="n">isRetrieving</span><span class="o">;</span>
</span><span class='line'>  <span class="kd">private</span> <span class="n">NetworkService</span> <span class="n">networkService</span><span class="o">;</span>
</span><span class='line'>
</span><span class='line'>  <span class="kd">public</span> <span class="nf">PictureProxy</span><span class="o">(</span><span class="n">NetworkService</span> <span class="n">ns</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>      <span class="n">networkService</span> <span class="o">=</span> <span class="n">ns</span><span class="o">;</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>  <span class="nd">@Override</span>
</span><span class='line'>  <span class="kd">public</span> <span class="n">String</span> <span class="nf">getName</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>      <span class="k">if</span> <span class="o">(</span><span class="n">contactPicture</span> <span class="o">==</span> <span class="kc">null</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>          <span class="n">retrieveImage</span><span class="o">();</span>
</span><span class='line'>      <span class="o">}</span> <span class="k">else</span> <span class="o">{</span>
</span><span class='line'>          <span class="n">contactPicture</span><span class="o">.</span><span class="na">getName</span><span class="o">();</span>
</span><span class='line'>      <span class="o">}</span>
</span><span class='line'>      <span class="k">return</span> <span class="kc">null</span><span class="o">;</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>  <span class="nd">@Override</span>
</span><span class='line'>  <span class="kd">public</span> <span class="n">String</span> <span class="nf">getFormat</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>      <span class="c1">// some code</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>  <span class="nd">@Override</span>
</span><span class='line'>  <span class="kd">public</span> <span class="kt">byte</span><span class="o">[]</span> <span class="nf">getImage</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>      <span class="c1">// some code</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'>
</span><span class='line'>  <span class="kd">private</span> <span class="kt">void</span> <span class="nf">retrieveImage</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>      <span class="k">if</span> <span class="o">(!</span><span class="n">isRetrieving</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>          <span class="n">isRetrieving</span> <span class="o">=</span> <span class="kc">true</span><span class="o">;</span>
</span><span class='line'>          <span class="n">Thread</span> <span class="n">thread</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">Thread</span><span class="o">(</span><span class="k">new</span> <span class="nf">Runnable</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>              <span class="nd">@Override</span>
</span><span class='line'>              <span class="kd">public</span> <span class="kt">void</span> <span class="nf">run</span><span class="o">()</span> <span class="o">{</span>
</span><span class='line'>                  <span class="k">try</span> <span class="o">{</span>
</span><span class='line'>                      <span class="n">contactPicture</span> <span class="o">=</span> <span class="k">new</span> <span class="nf">ContactPicture</span><span class="o">(</span><span class="s">&quot;john picture&quot;</span><span class="o">,</span>
</span><span class='line'>                          <span class="s">&quot;png&quot;</span><span class="o">,</span> <span class="n">networkService</span><span class="o">.</span><span class="na">getImage</span><span class="o">(</span><span class="k">new</span> <span class="nf">URL</span><span class="o">(</span><span class="s">&quot;http://imagerepo.com&quot;</span><span class="o">)));</span>
</span><span class='line'>                      <span class="n">System</span><span class="o">.</span><span class="na">out</span><span class="o">.</span><span class="na">println</span><span class="o">(</span><span class="s">&quot;picture retrieved&quot;</span><span class="o">);</span>
</span><span class='line'>                  <span class="o">}</span> <span class="k">catch</span> <span class="o">(</span><span class="n">MalformedURLException</span> <span class="n">e</span><span class="o">)</span> <span class="o">{</span>
</span><span class='line'>                      <span class="n">e</span><span class="o">.</span><span class="na">printStackTrace</span><span class="o">();</span>
</span><span class='line'>                  <span class="o">}</span>
</span><span class='line'>              <span class="o">}</span>
</span><span class='line'>          <span class="o">});</span>
</span><span class='line'>          <span class="n">thread</span><span class="o">.</span><span class="na">start</span><span class="o">();</span>
</span><span class='line'>      <span class="o">}</span>
</span><span class='line'>  <span class="o">}</span>
</span><span class='line'><span class="o">}</span>
</span></code></pre></td></tr></table></div></figure>

]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Proxy Pattern]]></title>
    <link href="http://blackat.github.io/blog/2013/03/20/proxy-pattern/"/>
    <updated>2013-03-20T23:00:00+01:00</updated>
    <id>http://blackat.github.io/blog/2013/03/20/proxy-pattern</id>
    <content type="html"><![CDATA[<blockquote><p>The Proxy Pattern provides a surrogate or placeholder for another object to control access to it.</p><footer><strong>Bates and Sierra,</strong> <cite><a href='http://shop.oreilly.com/product/9780596007126.do'>Head First Design Patterns</a></cite></footer></blockquote>


<!-- more -->


<h2>Class Diagram</h2>

<p><img src="http://blackat.github.io/images/posts/design-patterns/proxy.jpg"></p>

<p><code>Subject</code> interface is implemented by both <code>RealSubject</code> and <code>Proxy</code>. So they are <em>interchangeable</em> and it allows the <em>client</em> to treat the <code>Proxy</code> as <code>RealSubject</code>.</p>

<p><code>RealSubject</code> does the <em>real work</em> and the <code>Proxy</code> <u><em>controls the access</em></u> to it.</p>

<p><code>Proxy</code> handles the <em>creation</em> of the <code>RealSubject</code> keeping a <em>reference</em> to the <code>Subject</code> in order to be able to forward the request coming from the client to the real implementation.</p>

<p>Proxy can controls the access to the <em>real object</em> in different ways</p>

<ul>
<li><a href="http://blackat.github.io/blog/2013/03/22/remote-proxy-pattern"><strong>Remote proxy.</strong></a>

<ul>
<li>It <u>controls the access</u> to a <em>remote object</em>.</li>
<li>The proxy acts as a <em>local representative</em> for an object that <em>lives on different JVM</em>.</li>
<li><em>The object actually lives somewhere else on the network.</em></li>
</ul>
</li>
<li><a href="http://blackat.github.io/blog/2013/03/22/virtual-proxy-pattern"><strong>Virtual proxy.</strong></a>

<ul>
<li>It <u>controls the access</u> to a <em>resource</em> that is expensive to create.</li>
<li>The proxy acts as a <em>representative</em> for an object that may be expensive to create.</li>
<li>It <em>defers the creation</em> of the object until it is needed.</li>
<li>Virtual proxy acts as a <em>surrogate</em> for the object <em>before and while</em> it is being created.</li>
<li>Object is expensive to create because it has to be retrieved from a database over the network.</li>
</ul>
</li>
<li><a href="http://blackat.github.io/blog/2013/03/22/protection-proxy-pattern"><strong>Protection proxy.</strong></a>

<ul>
<li>It <u>controls the access</u> to a <em>resource</em> based on access rights.</li>
</ul>
</li>
<li><strong>Caching proxy.</strong> Similar to a virtual proxy but it <em>caches</em> the expensive objects it creates to reduce the latency of the forwarded request.</li>
</ul>


<h2>Key Points</h2>

<ul>
<li><strong>Proxy pattern</strong>

<ul>
<li>provides a surrogate or place holder for another object,</li>
<li>creates a representative object that <u><em>controls access</em></u> to another object which can be <em>remote</em>, <em>expensive to create</em> or <em>need secure access</em> to have its methods used.</li>
</ul>
</li>
<li><strong>Wrapper</strong>

<ul>
<li>In some way the proxy <em>wraps</em> (<code>HAS-A</code>) the real object.</li>
<li>Proxy <em>&ldquo;intercepts&rdquo;</em> the requests from the client and forwards them to the real object acting a some form of control on them.</li>
<li>If the real object is remote, there is a sort of <em>&ldquo;remote proxy&rdquo;</em> receiving the request or call over the network invoking the call of the method against the real object it owns.</li>
</ul>
</li>
<li><strong>Factory method</strong>    Using a <em>factory method</em> it is possible to <em>wrap</em> the <em>real object</em> into the proxy and return it to the client as it was the real one.</li>
</ul>


<h2>Comparisons</h2>

<p>All proxies have in common the ability to intercept a method call that a client has done. The client always invoke method on a <em>proxy</em> thinking that it is the <em>real object</em>. <em>Proxies always acts as surrogates.</em></p>

<h3>Proxy vs. Decorator and Adapter</h3>

<ul>
<li><strong>Proxy</strong>

<ul>
<li>It always <em>control the access</em> to a <em>class</em>.</li>
<li>Proxy decouples the client from the real object. Controlling the access, the proxy allow the client the use of the real object only when it is available, so the client doesn&rsquo;t have to wait for it.</li>
<li>The protection proxy may provides a partial interface to a real object, in this it is similar to an adapter.</li>
<li>It <strong>wraps the subject</strong>. The client doesn&rsquo;t know what object has been wrapped. Virtual proxy <em>wraps</em> an object that even doesn&rsquo;t exist at the beginning.</li>
</ul>
</li>
<li><strong>Decorator</strong>

<ul>
<li>It always <em>adds behavior</em> to a <em>class</em>.</li>
<li>It wraps an <strong>object</strong>.</li>
<li>It <em>never</em> instantiates anything.</li>
</ul>
</li>
<li><strong>Adapter</strong>

<ul>
<li>It forwards the request from the client to another object, but it <em>changes the interface</em> of the objects it adapts.</li>
<li>It is <em>different</em> from the <em>proxy</em> which always implement the <em>same interface</em> of the real object.</li>
</ul>
</li>
</ul>

]]></content>
  </entry>
  
</feed>