#352- Unit Of Work : Updated applicability of pattern in README.

converter/src/main/java/com/iluwatar/converter/App.java

@@ -41,10 +41,7 @@ public class App {
    * @param args command line args
    */
   public static void main(String[] args) {
-    Converter<UserDto, User> userConverter = new Converter<>(
-        userDto -> new User(userDto.getFirstName(), userDto.getLastName(), userDto.isActive(),
-          userDto.getEmail()),
-        user -> new UserDto(user.getFirstName(), user.getLastName(), user.isActive(), user.getUserId()));
+    Converter<UserDto, User> userConverter = new UserConverter();
 
     UserDto dtoUser = new UserDto("John", "Doe", true, "whatever[at]wherever.com");
     User user = userConverter.convertFromDto(dtoUser);

converter/src/main/java/com/iluwatar/converter/Converter.java

@@ -68,7 +68,7 @@ public class Converter<T, U> {
   /**
    * @param dtoUsers collection of DTO entities
    * @return List of domain representation of provided entities retrieved by
-   *        mapping each of them with the convertion function
+   *        mapping each of them with the conversion function
    */
   public final List<U> createFromDtos(final Collection<T> dtoUsers) {
     return dtoUsers.stream().map(this::convertFromDto).collect(Collectors.toList());
@@ -77,7 +77,7 @@ public class Converter<T, U> {
   /**
    * @param users collection of domain entities
    * @return List of domain representation of provided entities retrieved by
-   *        mapping each of them with the convertion function
+   *        mapping each of them with the conversion function
    */
   public final List<T> createFromEntities(final Collection<U> users) {
     return users.stream().map(this::convertFromEntity).collect(Collectors.toList());

decorator/README.md

@@ -35,7 +35,7 @@ Wikipedia says
 
 **Programmatic Example**
 
-Lets take the troll example. First of all we have a simple troll implementing the troll interface
+Let's take the troll example. First of all we have a simple troll implementing the troll interface
 
 ```
 public interface Troll {

eip-splitter/README.md

@@ -0,0 +1,32 @@
+---
+layout: pattern
+title: EIP Splitter
+folder: eip-splitter
+permalink: /patterns/eip-splitter/
+categories: Enterprise integration
+tags:
+ - Java
+ - Difficulty-Intermittent
+ - Enterprise integration
+---
+
+## Intent
+It is very common in integration systems that incoming messages consists of many items bundled together. For example
+an invoice document contains multiple invoice lines describing transaction (quantity, name of provided
+service/sold goods, price etc.). Such bundled messages may not be accepted by other systems. This is where splitter
+pattern comes in handy. It will take the whole document, split it based on given criteria and send individual
+items to the endpoint.
+
+![alt text](./etc/sequencer.gif "Splitter")
+
+## Applicability
+Use the Splitter pattern when
+
+* You need to split received data into smaller pieces to process them individually
+* You need to control the size of data batches you are able to process
+
+## Credits
+
+* [Gregor Hohpe, Bobby Woolf - Enterprise Integration Patterns](http://www.enterpriseintegrationpatterns.com/patterns/messaging/Sequencer.html)
+* [Apache Camel - Documentation](http://camel.apache.org/splitter.html)
+

eip-splitter/pom.xml

@@ -0,0 +1,63 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+    The MIT License
+    Copyright (c) 2014-2016 Ilkka Seppälä
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+    The above copyright notice and this permission notice shall be included in
+    all copies or substantial portions of the Software.
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+    THE SOFTWARE.
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>eip-splitter</artifactId>
+    <parent>
+        <groupId>com.iluwatar</groupId>
+        <artifactId>java-design-patterns</artifactId>
+        <version>1.18.0-SNAPSHOT</version>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.camel</groupId>
+            <artifactId>camel-core</artifactId>
+            <version>${camel.version}</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.camel</groupId>
+            <artifactId>camel-spring-boot</artifactId>
+            <version>${camel.version}</version>
+        </dependency>
+
+        <!-- Testing -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.camel</groupId>
+            <artifactId>camel-test-spring</artifactId>
+            <version>${camel.version}</version>
+        </dependency>
+
+    </dependencies>
+</project>

eip-splitter/src/main/java/com/iluwatar/eip/splitter/App.java

@@ -0,0 +1,53 @@
+package com.iluwatar.eip.splitter;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.builder.RouteBuilder;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.context.ConfigurableApplicationContext;
+
+/**
+ * It is very common in integration systems that incoming messages consists of many items bundled together. For example
+ * an invoice document contains multiple invoice lines describing transaction (quantity, name of provided
+ * service/sold goods, price etc.). Such bundled messages may not be accepted by other systems. This is where splitter
+ * pattern comes in handy. It will take the whole document, split it based on given criteria and send individual
+ * items to the endpoint.
+ *
+ * <p>
+ * Splitter allows you to split messages based on defined criteria. It takes original message, process it and send
+ * multiple parts to the output channel. It is not defined if it should keep the order of items though.
+ * </p>
+ *
+ */
+@SpringBootApplication
+public class App {
+
+  /**
+   * Program entry point. It starts Spring Boot application and using Apache Camel it auto-configures routes.
+   *
+   * @param args command line args
+   */
+  public static void main(String[] args) throws Exception {
+    // Run Spring Boot application and obtain ApplicationContext
+    ConfigurableApplicationContext context = SpringApplication.run(App.class, args);
+
+    // Get CamelContext from ApplicationContext
+    CamelContext camelContext = (CamelContext) context.getBean("camelContext");
+
+    // Add a new routes that will handle endpoints form SplitterRoute class.
+    camelContext.addRoutes(new RouteBuilder() {
+
+      @Override
+      public void configure() throws Exception {
+        from("{{endpoint}}").log("ENDPOINT: ${body}");
+      }
+
+    });
+
+    // Add producer that will send test message to an entry point in WireTapRoute
+    String[] stringArray = {"Test item #1", "Test item #2", "Test item #3"};
+    camelContext.createProducerTemplate().sendBody("{{entry}}", stringArray);
+
+    SpringApplication.exit(context);
+  }
+}

eip-splitter/src/main/java/com/iluwatar/eip/splitter/routes/SplitterRoute.java

@@ -0,0 +1,29 @@
+package com.iluwatar.eip.splitter.routes;
+
+import org.apache.camel.builder.RouteBuilder;
+import org.springframework.stereotype.Component;
+
+/**
+ * Sample splitter route definition.
+ *
+ * <p>
+ * It consumes messages out of the <i>direct:entry</i> entry point and forwards them to <i>direct:endpoint</i>.
+ * Route accepts messages having body of array or collection of objects. Splitter component split message body and
+ * forwards single objects to the endpoint.
+ * </p>
+ *
+ * In this example input/output endpoints names are stored in <i>application.properties</i> file.
+ */
+@Component
+public class SplitterRoute extends RouteBuilder {
+
+  /**
+   * Configures the route
+   * @throws Exception in case of exception during configuration
+   */
+  @Override
+  public void configure() throws Exception {
+    // Main route
+    from("{{entry}}").split().body().to("{{endpoint}}");
+  }
+}

eip-splitter/src/main/resources/application.properties

@@ -0,0 +1,2 @@
+entry=direct:entry
+endpoint=direct:endpoint

eip-splitter/src/test/java/com/iluwatar/eip/splitter/AppTest.java

@@ -0,0 +1,15 @@
+package com.iluwatar.eip.splitter;
+
+import org.junit.Test;
+
+/**
+ * Test for App class
+ */
+public class AppTest {
+
+  @Test
+  public void testMain() throws Exception {
+    String[] args = {};
+    App.main(args);
+  }
+}

eip-splitter/src/test/java/com/iluwatar/eip/splitter/routes/SplitterRouteTest.java

@@ -0,0 +1,53 @@
+package com.iluwatar.eip.splitter.routes;
+
+import org.apache.camel.EndpointInject;
+import org.apache.camel.Message;
+import org.apache.camel.ProducerTemplate;
+import org.apache.camel.component.mock.MockEndpoint;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
+import org.springframework.boot.test.SpringApplicationConfiguration;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.test.annotation.DirtiesContext;
+import org.springframework.test.context.ActiveProfiles;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * Test class for <i>SplitterRoute</i>.
+ * <p>
+ * In order for it to work we have to mock endpoints we want to read/write to. To mock those we need to substitute
+ * original endpoint names to mocks.
+ * </p>
+ */
+@RunWith(SpringJUnit4ClassRunner.class)
+@SpringApplicationConfiguration(classes = SplitterRouteTest.class)
+@ActiveProfiles("test")
+@EnableAutoConfiguration
+@ComponentScan
+public class SplitterRouteTest {
+
+  @EndpointInject(uri = "{{entry}}")
+  private ProducerTemplate entry;
+
+  @EndpointInject(uri = "{{endpoint}}")
+  private MockEndpoint endpoint;
+
+  /**
+   * Test if endpoint receives three separate messages.
+   * @throws Exception in case of en exception during the test
+   */
+  @Test
+  @DirtiesContext
+  public void testSplitter() throws Exception {
+
+    // Three items in one entry message
+    entry.sendBody(new String[] {"TEST1", "TEST2", "TEST3"});
+
+    // Endpoint should have three different messages in the end order of the messages is not important
+    endpoint.expectedMessageCount(3);
+    endpoint.assertIsSatisfied();
+  }
+}

eip-splitter/src/test/resources/application-test.properties

@@ -0,0 +1,2 @@
+entry=direct:entry
+endpoint=mock:endpoint

facade/README.md

@@ -203,7 +203,7 @@ Use the Facade pattern when
 
 * you want to provide a simple interface to a complex subsystem. Subsystems often get more complex  as they evolve. Most patterns, when applied, result in more and smaller classes. This makes the subsystem more reusable and easier to customize, but it also becomes harder to use for clients that don't need to customize it. A facade can provide a simple default view of the subsystem that is good enough for most clients. Only clients needing more customizability will need to look beyond the facade.
 * there are many dependencies between clients and the implementation classes of an abstraction. Introduce a facade to decouple the subsystem from clients and other subsystems, thereby promoting subsystem independence and portability.
-* you want to layer your subsystems. Use a facade to define an entry point to each subsystem level. If subsystems are dependent, the you can simplify the dependencies between them by making them communicate with each other solely through their facades
+* you want to layer your subsystems. Use a facade to define an entry point to each subsystem level. If subsystems are dependent, then you can simplify the dependencies between them by making them communicate with each other solely through their facades.
 
 ## Credits
 

pom.xml

@@ -150,6 +150,7 @@
         <module>unit-of-work</module>
         <module>partial-response</module>
         <module>eip-wire-tap</module>
+        <module>eip-splitter</module>
     </modules>
 
     <dependencyManagement>