+ * 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.
+ */
+package com.iluwatar.abstractdocument;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.function.Function;
+import java.util.stream.Stream;
+
+/**
+ * Abstract implementation of Document interface
+ */
+public abstract class AbstractDocument implements Document {
+
+ private final Map
+ * 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.
+ */
+package com.iluwatar.abstractdocument;
+
+import com.iluwatar.abstractdocument.domain.Car;
+import com.iluwatar.abstractdocument.domain.HasModel;
+import com.iluwatar.abstractdocument.domain.HasParts;
+import com.iluwatar.abstractdocument.domain.HasPrice;
+import com.iluwatar.abstractdocument.domain.HasType;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * The Abstract Document pattern enables handling additional, non-static
+ * properties. This pattern uses concept of traits to enable type safety and
+ * separate properties of different classes into set of interfaces.
+ *
+ *
+ * In Abstract Document pattern,({@link AbstractDocument}) fully implements
+ * {@link Document}) interface. Traits are then defined to enable access to
+ * properties in usual, static way.
+ */
+public class App {
+
+ /**
+ * Executes the App
+ */
+ public App() {
+ System.out.println("Constructing parts and car");
+
+ Map
+ * 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.
+ */
+package com.iluwatar.abstractdocument;
+
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Stream;
+
+/**
+ * Document interface
+ */
+public interface Document {
+
+ /**
+ * Puts the value related to the key
+ *
+ * @param key element key
+ * @param value element value
+ * @return Void
+ */
+ Void put(String key, Object value);
+
+ /**
+ * Gets the value for the key
+ *
+ * @param key element key
+ * @return value or null
+ */
+ Object get(String key);
+
+ /**
+ * Gets the stream of child documents
+ *
+ * @param key element key
+ * @param constructor constructor of child class
+ * @return child documents
+ */
+
+ * 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.
+ */
+package com.iluwatar.abstractdocument.domain;
+
+import java.util.Map;
+
+import com.iluwatar.abstractdocument.AbstractDocument;
+
+/**
+ * Car entity
+ */
+public class Car extends AbstractDocument implements HasModel, HasPrice, HasParts {
+
+ public Car(Map
+ * 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.
+ */
+package com.iluwatar.abstractdocument.domain;
+
+import java.util.Optional;
+
+import com.iluwatar.abstractdocument.Document;
+
+/**
+ * HasModel trait for static access to 'model' property
+ */
+public interface HasModel extends Document {
+
+ String PROPERTY = "model";
+
+ default Optional
+ * 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.
+ */
+package com.iluwatar.abstractdocument.domain;
+
+import java.util.stream.Stream;
+
+import com.iluwatar.abstractdocument.Document;
+
+/**
+ * HasParts trait for static access to 'parts' property
+ */
+public interface HasParts extends Document {
+
+ String PROPERTY = "parts";
+
+ default Stream
+ * 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.
+ */
+package com.iluwatar.abstractdocument.domain;
+
+import java.util.Optional;
+
+import com.iluwatar.abstractdocument.Document;
+
+/**
+ * HasPrice trait for static access to 'price' property
+ */
+public interface HasPrice extends Document {
+
+ String PROPERTY = "price";
+
+ default Optional
+ * 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.
+ */
+package com.iluwatar.abstractdocument.domain;
+
+import com.iluwatar.abstractdocument.Document;
+
+import java.util.Optional;
+
+/**
+ * HasType trait for static access to 'type' property
+ */
+public interface HasType extends Document {
+
+ String PROPERTY = "type";
+
+ default Optional
+ * 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.
+ */
+package com.iluwatar.abstractdocument.domain;
+
+import java.util.Map;
+
+import com.iluwatar.abstractdocument.AbstractDocument;
+
+/**
+ * Part entity
+ */
+public class Part extends AbstractDocument implements HasType, HasModel, HasPrice {
+
+ public Part(Map
+ * 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.
+ */
+package com.iluwatar.abstractdocument;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Stream;
+
+import static junit.framework.TestCase.assertEquals;
+import static junit.framework.TestCase.assertNotNull;
+
+/**
+ * AbstractDocument test class
+ */
+public class AbstractDocumentTest {
+
+ private static final String KEY = "key";
+ private static final String VALUE = "value";
+
+ private class DocumentImplementation extends AbstractDocument {
+
+ DocumentImplementation(Map
+ * 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.
+ */
+package com.iluwatar.abstractdocument;
+
+import org.junit.Test;
+
+/**
+ * Simple App test
+ */
+public class AppTest {
+
+ @Test
+ public void shouldExecuteAppWithoutException() {
+ App.main(null);
+ }
+
+}
diff --git a/abstract-document/src/test/java/com/iluwatar/abstractdocument/DomainTest.java b/abstract-document/src/test/java/com/iluwatar/abstractdocument/DomainTest.java
new file mode 100644
index 000000000000..437244a3d34f
--- /dev/null
+++ b/abstract-document/src/test/java/com/iluwatar/abstractdocument/DomainTest.java
@@ -0,0 +1,77 @@
+/**
+ * The MIT License
+ * Copyright (c) 2014 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.
+ */
+package com.iluwatar.abstractdocument;
+
+import com.iluwatar.abstractdocument.domain.Car;
+import com.iluwatar.abstractdocument.domain.HasModel;
+import com.iluwatar.abstractdocument.domain.HasParts;
+import com.iluwatar.abstractdocument.domain.HasPrice;
+import com.iluwatar.abstractdocument.domain.HasType;
+import com.iluwatar.abstractdocument.domain.Part;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+import static junit.framework.TestCase.assertEquals;
+
+/**
+ * Test for Part and Car
+ */
+public class DomainTest {
+
+ private static final String TEST_PART_TYPE = "test-part-type";
+ private static final String TEST_PART_MODEL = "test-part-model";
+ private static final long TEST_PART_PRICE = 0L;
+
+ private static final String TEST_CAR_MODEL = "test-car-model";
+ private static final long TEST_CAR_PRICE = 1L;
+
+ @Test
+ public void shouldConstructPart() {
+ Map
+ * The intent of the API Gateway pattern is to alleviate some of these issues. In the API Gateway
+ * pattern, an additional entity (the API Gateway) is placed between the client and the
+ * microservices. The job of the API Gateway is to aggregate the calls to the microservices.
+ * Rather than the client calling each microservice individually, the client calls the API Gateway
+ * a single time. The API Gateway then calls each of the microservices that the client needs.
+ *
+ *
+ * This implementation shows what the API Gateway pattern could look like for an e-commerce site.
+ * The {@link ApiGateway} makes calls to the Image and Price microservices using the
+ * {@link ImageClientImpl} and {@link PriceClientImpl} respectively. Customers viewing the site on a
+ * desktop device can see both price information and an image of a product, so the {@link ApiGateway}
+ * calls both of the microservices and aggregates the data in the {@link DesktopProduct} model.
+ * However, mobile users only see price information; they do not see a product image. For mobile
+ * users, the {@link ApiGateway} only retrieves price information, which it uses to populate the
+ * {@link MobileProduct}.
+ */
+@SpringBootApplication
+public class App {
+
+ /**
+ * Program entry point
+ *
+ * @param args
+ * command line args
+ */
+ public static void main(String[] args) {
+ SpringApplication.run(App.class, args);
+ }
+}
diff --git a/api-gateway/api-gateway-service/src/main/java/com/iluwatar/api/gateway/DesktopProduct.java b/api-gateway/api-gateway-service/src/main/java/com/iluwatar/api/gateway/DesktopProduct.java
new file mode 100644
index 000000000000..0a04db4022b9
--- /dev/null
+++ b/api-gateway/api-gateway-service/src/main/java/com/iluwatar/api/gateway/DesktopProduct.java
@@ -0,0 +1,54 @@
+/**
+ * The MIT License
+ * Copyright (c) 2014 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.
+ */
+package com.iluwatar.api.gateway;
+
+/**
+ * Encapsulates all of the information that a desktop client needs to display a product.
+ */
+public class DesktopProduct {
+ /**
+ * The price of the product
+ */
+ private String price;
+
+ /**
+ * The path to the image of the product
+ */
+ private String imagePath;
+
+ public String getPrice() {
+ return price;
+ }
+
+ public void setPrice(String price) {
+ this.price = price;
+ }
+
+ public String getImagePath() {
+ return imagePath;
+ }
+
+ public void setImagePath(String imagePath) {
+ this.imagePath = imagePath;
+ }
+}
diff --git a/api-gateway/api-gateway-service/src/main/java/com/iluwatar/api/gateway/ImageClient.java b/api-gateway/api-gateway-service/src/main/java/com/iluwatar/api/gateway/ImageClient.java
new file mode 100644
index 000000000000..935dab7781a7
--- /dev/null
+++ b/api-gateway/api-gateway-service/src/main/java/com/iluwatar/api/gateway/ImageClient.java
@@ -0,0 +1,30 @@
+/**
+ * The MIT License
+ * Copyright (c) 2014 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.
+ */
+package com.iluwatar.api.gateway;
+
+/**
+ * An interface used to communicate with the Image microservice
+ */
+public interface ImageClient {
+ String getImagePath();
+}
diff --git a/api-gateway/api-gateway-service/src/main/java/com/iluwatar/api/gateway/ImageClientImpl.java b/api-gateway/api-gateway-service/src/main/java/com/iluwatar/api/gateway/ImageClientImpl.java
new file mode 100644
index 000000000000..64fde1e66230
--- /dev/null
+++ b/api-gateway/api-gateway-service/src/main/java/com/iluwatar/api/gateway/ImageClientImpl.java
@@ -0,0 +1,56 @@
+/**
+ * The MIT License
+ * Copyright (c) 2014 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.
+ */
+package com.iluwatar.api.gateway;
+
+import org.apache.http.client.methods.CloseableHttpResponse;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.impl.client.HttpClients;
+import org.apache.http.util.EntityUtils;
+import org.springframework.stereotype.Component;
+
+import java.io.IOException;
+
+/**
+ * An adapter to communicate with the Image microservice
+ */
+@Component
+public class ImageClientImpl implements ImageClient{
+ /**
+ * Makes a simple HTTP Get request to the Image microservice
+ * @return The path to the image
+ */
+ @Override
+ public String getImagePath() {
+ String response = null;
+ try (CloseableHttpClient httpClient = HttpClients.createDefault()) {
+ HttpGet httpGet = new HttpGet("http://localhost:50005/image-path");
+ try (CloseableHttpResponse httpResponse = httpClient.execute(httpGet)) {
+ response = EntityUtils.toString(httpResponse.getEntity());
+ }
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ return response;
+ }
+}
diff --git a/api-gateway/api-gateway-service/src/main/java/com/iluwatar/api/gateway/MobileProduct.java b/api-gateway/api-gateway-service/src/main/java/com/iluwatar/api/gateway/MobileProduct.java
new file mode 100644
index 000000000000..db358b781fbd
--- /dev/null
+++ b/api-gateway/api-gateway-service/src/main/java/com/iluwatar/api/gateway/MobileProduct.java
@@ -0,0 +1,41 @@
+/**
+ * The MIT License
+ * Copyright (c) 2014 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.
+ */
+package com.iluwatar.api.gateway;
+
+/**
+ * Encapsulates all of the information that mobile client needs to display a product.
+ */
+public class MobileProduct {
+ /**
+ * The price of the product
+ */
+ private String price;
+
+ public String getPrice() {
+ return price;
+ }
+
+ public void setPrice(String price) {
+ this.price = price;
+ }
+}
diff --git a/api-gateway/api-gateway-service/src/main/java/com/iluwatar/api/gateway/PriceClient.java b/api-gateway/api-gateway-service/src/main/java/com/iluwatar/api/gateway/PriceClient.java
new file mode 100644
index 000000000000..44497b99710c
--- /dev/null
+++ b/api-gateway/api-gateway-service/src/main/java/com/iluwatar/api/gateway/PriceClient.java
@@ -0,0 +1,30 @@
+/**
+ * The MIT License
+ * Copyright (c) 2014 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.
+ */
+package com.iluwatar.api.gateway;
+
+/**
+ * An interface used to communicate with the Price microservice
+ */
+public interface PriceClient {
+ String getPrice();
+}
diff --git a/api-gateway/api-gateway-service/src/main/java/com/iluwatar/api/gateway/PriceClientImpl.java b/api-gateway/api-gateway-service/src/main/java/com/iluwatar/api/gateway/PriceClientImpl.java
new file mode 100644
index 000000000000..bdc7cb00bd73
--- /dev/null
+++ b/api-gateway/api-gateway-service/src/main/java/com/iluwatar/api/gateway/PriceClientImpl.java
@@ -0,0 +1,56 @@
+/**
+ * The MIT License
+ * Copyright (c) 2014 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.
+ */
+package com.iluwatar.api.gateway;
+
+import org.apache.http.client.methods.CloseableHttpResponse;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.impl.client.HttpClients;
+import org.apache.http.util.EntityUtils;
+import org.springframework.stereotype.Component;
+
+import java.io.IOException;
+
+/**
+ * An adapter to communicate with the Price microservice
+ */
+@Component
+public class PriceClientImpl implements PriceClient{
+ /**
+ * Makes a simple HTTP Get request to the Price microservice
+ * @return The price of the product
+ */
+ @Override
+ public String getPrice() {
+ String response = null;
+ try (CloseableHttpClient httpClient = HttpClients.createDefault()) {
+ HttpGet httpGet = new HttpGet("http://localhost:50006/price");
+ try (CloseableHttpResponse httpResponse = httpClient.execute(httpGet)) {
+ response = EntityUtils.toString(httpResponse.getEntity());
+ }
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ return response;
+ }
+}
diff --git a/api-gateway/api-gateway-service/src/main/resources/application.properties b/api-gateway/api-gateway-service/src/main/resources/application.properties
new file mode 100644
index 000000000000..69f58171237a
--- /dev/null
+++ b/api-gateway/api-gateway-service/src/main/resources/application.properties
@@ -0,0 +1,24 @@
+#
+# The MIT License
+# Copyright (c) 2014 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.
+#
+
+server.port=50004
\ No newline at end of file
diff --git a/api-gateway/api-gateway-service/src/test/java/com/iluwatar/api/gateway/ApiGatewayTest.java b/api-gateway/api-gateway-service/src/test/java/com/iluwatar/api/gateway/ApiGatewayTest.java
new file mode 100644
index 000000000000..d1a210f05db4
--- /dev/null
+++ b/api-gateway/api-gateway-service/src/test/java/com/iluwatar/api/gateway/ApiGatewayTest.java
@@ -0,0 +1,78 @@
+/**
+ * The MIT License
+ * Copyright (c) 2014 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.
+ */
+package com.iluwatar.api.gateway;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.when;
+
+public class ApiGatewayTest {
+
+ @InjectMocks
+ private ApiGateway apiGateway;
+
+ @Mock
+ private ImageClient imageClient;
+
+ @Mock
+ private PriceClient priceClient;
+
+ @Before
+ public void setup() {
+ MockitoAnnotations.initMocks(this);
+ }
+
+ /**
+ * Tests getting the data for a desktop client
+ */
+ @Test
+ public void testGetProductDesktop() {
+ String imagePath = "/product-image.png";
+ String price = "20";
+ when(imageClient.getImagePath()).thenReturn(imagePath);
+ when(priceClient.getPrice()).thenReturn(price);
+
+ DesktopProduct desktopProduct = apiGateway.getProductDesktop();
+
+ assertEquals(price, desktopProduct.getPrice());
+ assertEquals(imagePath, desktopProduct.getImagePath());
+ }
+
+ /**
+ * Tests getting the data for a mobile client
+ */
+ @Test
+ public void testGetProductMobile() {
+ String price = "20";
+ when(priceClient.getPrice()).thenReturn(price);
+
+ MobileProduct mobileProduct = apiGateway.getProductMobile();
+
+ assertEquals(price, mobileProduct.getPrice());
+ }
+}
diff --git a/api-gateway/etc/api-gateway-service.urm.puml b/api-gateway/etc/api-gateway-service.urm.puml
new file mode 100644
index 000000000000..409e7ee91842
--- /dev/null
+++ b/api-gateway/etc/api-gateway-service.urm.puml
@@ -0,0 +1,48 @@
+@startuml
+package com.iluwatar.api.gateway {
+ class App {
+ + App()
+ + main(args : String[]) {static}
+ }
+ class PriceClientImpl {
+ + PriceClientImpl()
+ + getPrice() : String
+ }
+ class ImageClientImpl {
+ + ImageClientImpl()
+ + getImagePath() : String
+ }
+ class MobileProduct {
+ - price : String
+ + MobileProduct()
+ + getPrice() : String
+ + setPrice(price : String)
+ }
+ interface ImageClient {
+ + getImagePath() : String {abstract}
+ }
+ class ApiGateway {
+ - imageClient : ImageClient
+ - priceClient : PriceClient
+ + ApiGateway()
+ + getProductDesktop() : DesktopProduct
+ + getProductMobile() : MobileProduct
+ }
+ class DesktopProduct {
+ - imagePath : String
+ - price : String
+ + DesktopProduct()
+ + getImagePath() : String
+ + getPrice() : String
+ + setImagePath(imagePath : String)
+ + setPrice(price : String)
+ }
+ interface PriceClient {
+ + getPrice() : String {abstract}
+ }
+}
+ApiGateway --> "-imageClient" ImageClient
+ApiGateway --> "-priceClient" PriceClient
+PriceClientImpl ..|> PriceClient
+ImageClientImpl ..|> ImageClient
+@enduml
\ No newline at end of file
diff --git a/api-gateway/etc/api-gateway.png b/api-gateway/etc/api-gateway.png
new file mode 100644
index 000000000000..bb3ec2e2e1a8
Binary files /dev/null and b/api-gateway/etc/api-gateway.png differ
diff --git a/api-gateway/etc/api-gateway.ucls b/api-gateway/etc/api-gateway.ucls
new file mode 100644
index 000000000000..4a74c2108b22
--- /dev/null
+++ b/api-gateway/etc/api-gateway.ucls
@@ -0,0 +1,97 @@
+
+
* We want to build {@link Hero} objects, but its construction is complex because of the many
- * parameters needed. To aid the user we introduce {@link HeroBuilder} class. {@link HeroBuilder}
+ * parameters needed. To aid the user we introduce {@link Builder} class. {@link Hero.Builder}
* takes the minimum parameters to build {@link Hero} object in its constructor. After that
* additional configuration for the {@link Hero} object can be done using the fluent
- * {@link HeroBuilder} interface. When configuration is ready the build method is called to receive
+ * {@link Builder} interface. When configuration is ready the build method is called to receive
* the final {@link Hero} object.
*
*/
@@ -58,18 +58,18 @@ public class App {
public static void main(String[] args) {
Hero mage =
- new HeroBuilder(Profession.MAGE, "Riobard").withHairColor(HairColor.BLACK)
+ new Hero.Builder(Profession.MAGE, "Riobard").withHairColor(HairColor.BLACK)
.withWeapon(Weapon.DAGGER).build();
System.out.println(mage);
Hero warrior =
- new HeroBuilder(Profession.WARRIOR, "Amberjill").withHairColor(HairColor.BLOND)
+ new Hero.Builder(Profession.WARRIOR, "Amberjill").withHairColor(HairColor.BLOND)
.withHairType(HairType.LONG_CURLY).withArmor(Armor.CHAIN_MAIL).withWeapon(Weapon.SWORD)
.build();
System.out.println(warrior);
Hero thief =
- new HeroBuilder(Profession.THIEF, "Desmond").withHairType(HairType.BALD)
+ new Hero.Builder(Profession.THIEF, "Desmond").withHairType(HairType.BALD)
.withWeapon(Weapon.BOW).build();
System.out.println(thief);
diff --git a/builder/src/main/java/com/iluwatar/builder/Hero.java b/builder/src/main/java/com/iluwatar/builder/Hero.java
index 1835df6384b5..25445851a2bb 100644
--- a/builder/src/main/java/com/iluwatar/builder/Hero.java
+++ b/builder/src/main/java/com/iluwatar/builder/Hero.java
@@ -36,7 +36,7 @@ public final class Hero {
private final Armor armor;
private final Weapon weapon;
- private Hero(HeroBuilder builder) {
+ private Hero(Builder builder) {
this.profession = builder.profession;
this.name = builder.name;
this.hairColor = builder.hairColor;
@@ -102,7 +102,7 @@ public String toString() {
* The builder class.
*
*/
- public static class HeroBuilder {
+ public static class Builder {
private final Profession profession;
private final String name;
@@ -114,7 +114,7 @@ public static class HeroBuilder {
/**
* Constructor
*/
- public HeroBuilder(Profession profession, String name) {
+ public Builder(Profession profession, String name) {
if (profession == null || name == null) {
throw new IllegalArgumentException("profession and name can not be null");
}
@@ -122,22 +122,22 @@ public HeroBuilder(Profession profession, String name) {
this.name = name;
}
- public HeroBuilder withHairType(HairType hairType) {
+ public Builder withHairType(HairType hairType) {
this.hairType = hairType;
return this;
}
- public HeroBuilder withHairColor(HairColor hairColor) {
+ public Builder withHairColor(HairColor hairColor) {
this.hairColor = hairColor;
return this;
}
- public HeroBuilder withArmor(Armor armor) {
+ public Builder withArmor(Armor armor) {
this.armor = armor;
return this;
}
- public HeroBuilder withWeapon(Weapon weapon) {
+ public Builder withWeapon(Weapon weapon) {
this.weapon = weapon;
return this;
}
diff --git a/builder/src/test/java/com/iluwatar/builder/HeroTest.java b/builder/src/test/java/com/iluwatar/builder/HeroTest.java
index 3c308e8c1e05..b0a73a9d0ed7 100644
--- a/builder/src/test/java/com/iluwatar/builder/HeroTest.java
+++ b/builder/src/test/java/com/iluwatar/builder/HeroTest.java
@@ -39,7 +39,7 @@ public class HeroTest {
*/
@Test(expected = IllegalArgumentException.class)
public void testMissingProfession() throws Exception {
- new Hero.HeroBuilder(null, "Sir without a job");
+ new Hero.Builder(null, "Sir without a job");
}
/**
@@ -47,7 +47,7 @@ public void testMissingProfession() throws Exception {
*/
@Test(expected = IllegalArgumentException.class)
public void testMissingName() throws Exception {
- new Hero.HeroBuilder(Profession.THIEF, null);
+ new Hero.Builder(Profession.THIEF, null);
}
/**
@@ -57,7 +57,7 @@ public void testMissingName() throws Exception {
public void testBuildHero() throws Exception {
final String heroName = "Sir Lancelot";
- final Hero hero = new Hero.HeroBuilder(Profession.WARRIOR, heroName)
+ final Hero hero = new Hero.Builder(Profession.WARRIOR, heroName)
.withArmor(Armor.CHAIN_MAIL)
.withWeapon(Weapon.SWORD)
.withHairType(HairType.LONG_CURLY)
diff --git a/business-delegate/README.md b/business-delegate/README.md
index e6e2491222e0..8e6e3456c410 100644
--- a/business-delegate/README.md
+++ b/business-delegate/README.md
@@ -3,6 +3,7 @@ layout: pattern
title: Business Delegate
folder: business-delegate
permalink: /patterns/business-delegate/
+pumlid: POl13SCm3CHMQGU8zUysgYCuBcJ5a4x9-l6_Fu84tzsgvYxf-Zg06HyYvxkqZYE_6UBrD8YXr7DGrxmPxFJZYxTTeZVR9WFY5ZGu5j2wkad4wYgD8IIe_xQaZp9pw0C0
categories: Business Tier
tags:
- Java
diff --git a/business-delegate/etc/business-delegate.urm.puml b/business-delegate/etc/business-delegate.urm.puml
new file mode 100644
index 000000000000..a58136c8ce8d
--- /dev/null
+++ b/business-delegate/etc/business-delegate.urm.puml
@@ -0,0 +1,55 @@
+@startuml
+package com.iluwatar.business.delegate {
+ class EjbService {
+ + EjbService()
+ + doProcessing()
+ }
+ class BusinessLookup {
+ - ejbService : EjbService
+ - jmsService : JmsService
+ + BusinessLookup()
+ + getBusinessService(serviceType : ServiceType) : BusinessService
+ + setEjbService(ejbService : EjbService)
+ + setJmsService(jmsService : JmsService)
+ }
+ class App {
+ + App()
+ + main(args : String[]) {static}
+ }
+ interface BusinessService {
+ + doProcessing() {abstract}
+ }
+ class Client {
+ - businessDelegate : BusinessDelegate
+ + Client(businessDelegate : BusinessDelegate)
+ + doTask()
+ }
+ class BusinessDelegate {
+ - businessService : BusinessService
+ - lookupService : BusinessLookup
+ - serviceType : ServiceType
+ + BusinessDelegate()
+ + doTask()
+ + setLookupService(businessLookup : BusinessLookup)
+ + setServiceType(serviceType : ServiceType)
+ }
+ class JmsService {
+ + JmsService()
+ + doProcessing()
+ }
+ enum ServiceType {
+ + EJB {static}
+ + JMS {static}
+ + valueOf(name : String) : ServiceType {static}
+ + values() : ServiceType[] {static}
+ }
+}
+BusinessDelegate --> "-serviceType" ServiceType
+BusinessLookup --> "-ejbService" EjbService
+Client --> "-businessDelegate" BusinessDelegate
+BusinessDelegate --> "-businessService" BusinessService
+BusinessDelegate --> "-lookupService" BusinessLookup
+BusinessLookup --> "-jmsService" JmsService
+EjbService ..|> BusinessService
+JmsService ..|> BusinessService
+@enduml
\ No newline at end of file
diff --git a/business-delegate/pom.xml b/business-delegate/pom.xml
index 3834b4c8fee4..2b0ce9119386 100644
--- a/business-delegate/pom.xml
+++ b/business-delegate/pom.xml
@@ -30,7 +30,7 @@
* In this example, the user account ({@link UserAccount}) entity is used as the underlying
* application data. The cache itself is implemented as an internal (Java) data structure. It adopts
- * a Least-Recently-Used (LRU) strategy for evicting data from itself when its full. The three
+ * a Least-Recently-Used (LRU) strategy for evicting data from itself when its full. The four
* strategies are individually tested. The testing of the cache is restricted towards saving and
* querying of user accounts from the underlying data store ( {@link DbManager}). The main class (
* {@link App} is not aware of the underlying mechanics of the application (i.e. save and query) and
@@ -74,6 +75,7 @@ public static void main(String[] args) {
app.useReadAndWriteThroughStrategy();
app.useReadThroughAndWriteAroundStrategy();
app.useReadThroughAndWriteBehindStrategy();
+ app.useCacheAsideStategy();
}
/**
@@ -136,4 +138,26 @@ public void useReadThroughAndWriteBehindStrategy() {
AppManager.find("004");
System.out.println(AppManager.printCacheContent());
}
+
+ /**
+ * Cache-Aside
+ */
+ public void useCacheAsideStategy() {
+ System.out.println("# CachingPolicy.ASIDE");
+ AppManager.initCachingPolicy(CachingPolicy.ASIDE);
+ System.out.println(AppManager.printCacheContent());
+
+ UserAccount userAccount3 = new UserAccount("003", "Adam", "He likes food.");
+ UserAccount userAccount4 = new UserAccount("004", "Rita", "She hates cats.");
+ UserAccount userAccount5 = new UserAccount("005", "Isaac", "He is allergic to mustard.");
+ AppManager.save(userAccount3);
+ AppManager.save(userAccount4);
+ AppManager.save(userAccount5);
+
+ System.out.println(AppManager.printCacheContent());
+ AppManager.find("003");
+ System.out.println(AppManager.printCacheContent());
+ AppManager.find("004");
+ System.out.println(AppManager.printCacheContent());
+ }
}
diff --git a/caching/src/main/java/com/iluwatar/caching/AppManager.java b/caching/src/main/java/com/iluwatar/caching/AppManager.java
index 2967c759f7b7..2d6a424a35b4 100644
--- a/caching/src/main/java/com/iluwatar/caching/AppManager.java
+++ b/caching/src/main/java/com/iluwatar/caching/AppManager.java
@@ -64,12 +64,7 @@ public static void initDb(boolean useMongoDb) {
public static void initCachingPolicy(CachingPolicy policy) {
cachingPolicy = policy;
if (cachingPolicy == CachingPolicy.BEHIND) {
- Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
- @Override
- public void run() {
- CacheStore.flushCache();
- }
- }));
+ Runtime.getRuntime().addShutdownHook(new Thread(CacheStore::flushCache));
}
CacheStore.clearCache();
}
@@ -86,6 +81,8 @@ public static UserAccount find(String userId) {
return CacheStore.readThrough(userId);
} else if (cachingPolicy == CachingPolicy.BEHIND) {
return CacheStore.readThroughWithWriteBackPolicy(userId);
+ } else if (cachingPolicy == CachingPolicy.ASIDE) {
+ return findAside(userId);
}
return null;
}
@@ -100,10 +97,37 @@ public static void save(UserAccount userAccount) {
CacheStore.writeAround(userAccount);
} else if (cachingPolicy == CachingPolicy.BEHIND) {
CacheStore.writeBehind(userAccount);
+ } else if (cachingPolicy == CachingPolicy.ASIDE) {
+ saveAside(userAccount);
}
}
public static String printCacheContent() {
return CacheStore.print();
}
+
+ /**
+ * Cache-Aside save user account helper
+ */
+ private static void saveAside(UserAccount userAccount) {
+ DbManager.updateDb(userAccount);
+ CacheStore.invalidate(userAccount.getUserId());
+ }
+
+ /**
+ * Cache-Aside find user account helper
+ */
+ private static UserAccount findAside(String userId) {
+ UserAccount userAccount = CacheStore.get(userId);
+ if (userAccount != null) {
+ return userAccount;
+ }
+
+ userAccount = DbManager.readFromDb(userId);
+ if (userAccount != null) {
+ CacheStore.set(userId, userAccount);
+ }
+
+ return userAccount;
+ }
}
diff --git a/caching/src/main/java/com/iluwatar/caching/CacheStore.java b/caching/src/main/java/com/iluwatar/caching/CacheStore.java
index 5903f82193e9..c2b95a1bdb55 100644
--- a/caching/src/main/java/com/iluwatar/caching/CacheStore.java
+++ b/caching/src/main/java/com/iluwatar/caching/CacheStore.java
@@ -40,7 +40,7 @@ private CacheStore() {
* Init cache capacity
*/
public static void initCapacity(int capacity) {
- if (null == cache) {
+ if (cache == null) {
cache = new LruCache(capacity);
} else {
cache.setCapacity(capacity);
@@ -121,7 +121,7 @@ public static void writeBehind(UserAccount userAccount) {
* Clears cache
*/
public static void clearCache() {
- if (null != cache) {
+ if (cache != null) {
cache.clear();
}
}
@@ -153,4 +153,25 @@ public static String print() {
sb.append("----\n");
return sb.toString();
}
+
+ /**
+ * Delegate to backing cache store
+ */
+ public static UserAccount get(String userId) {
+ return cache.get(userId);
+ }
+
+ /**
+ * Delegate to backing cache store
+ */
+ public static void set(String userId, UserAccount userAccount) {
+ cache.set(userId, userAccount);
+ }
+
+ /**
+ * Delegate to backing cache store
+ */
+ public static void invalidate(String userId) {
+ cache.invalidate(userId);
+ }
}
diff --git a/caching/src/main/java/com/iluwatar/caching/CachingPolicy.java b/caching/src/main/java/com/iluwatar/caching/CachingPolicy.java
index 490113baa3d9..5ad32f6993a5 100644
--- a/caching/src/main/java/com/iluwatar/caching/CachingPolicy.java
+++ b/caching/src/main/java/com/iluwatar/caching/CachingPolicy.java
@@ -24,11 +24,11 @@
/**
*
- * Enum class containing the three caching strategies implemented in the pattern.
+ * Enum class containing the four caching strategies implemented in the pattern.
*
*/
public enum CachingPolicy {
- THROUGH("through"), AROUND("around"), BEHIND("behind");
+ THROUGH("through"), AROUND("around"), BEHIND("behind"), ASIDE("aside");
private String policy;
diff --git a/caching/src/main/java/com/iluwatar/caching/DbManager.java b/caching/src/main/java/com/iluwatar/caching/DbManager.java
index c12461d0c690..455302106b57 100644
--- a/caching/src/main/java/com/iluwatar/caching/DbManager.java
+++ b/caching/src/main/java/com/iluwatar/caching/DbManager.java
@@ -82,7 +82,7 @@ public static UserAccount readFromDb(String userId) {
}
return null;
}
- if (null == db) {
+ if (db == null) {
try {
connect();
} catch (ParseException e) {
@@ -106,7 +106,7 @@ public static void writeToDb(UserAccount userAccount) {
virtualDB.put(userAccount.getUserId(), userAccount);
return;
}
- if (null == db) {
+ if (db == null) {
try {
connect();
} catch (ParseException e) {
@@ -126,7 +126,7 @@ public static void updateDb(UserAccount userAccount) {
virtualDB.put(userAccount.getUserId(), userAccount);
return;
}
- if (null == db) {
+ if (db == null) {
try {
connect();
} catch (ParseException e) {
@@ -148,7 +148,7 @@ public static void upsertDb(UserAccount userAccount) {
virtualDB.put(userAccount.getUserId(), userAccount);
return;
}
- if (null == db) {
+ if (db == null) {
try {
connect();
} catch (ParseException e) {
diff --git a/caching/src/main/java/com/iluwatar/caching/LruCache.java b/caching/src/main/java/com/iluwatar/caching/LruCache.java
index 5c5549afd9d7..00e27ccf1fc1 100644
--- a/caching/src/main/java/com/iluwatar/caching/LruCache.java
+++ b/caching/src/main/java/com/iluwatar/caching/LruCache.java
@@ -73,7 +73,6 @@ public UserAccount get(String userId) {
}
/**
- *
* Remove node from linked list.
*/
public void remove(Node node) {
@@ -90,7 +89,6 @@ public void remove(Node node) {
}
/**
- *
* Move node to the front of the list.
*/
public void setHead(Node node) {
@@ -136,10 +134,11 @@ public boolean contains(String userId) {
* Invalidate cache for user
*/
public void invalidate(String userId) {
- System.out.println("# " + userId + " has been updated! Removing older version from cache...");
- Node toBeRemoved = cache.get(userId);
- remove(toBeRemoved);
- cache.remove(userId);
+ Node toBeRemoved = cache.remove(userId);
+ if (toBeRemoved != null) {
+ System.out.println("# " + userId + " has been updated! Removing older version from cache...");
+ remove(toBeRemoved);
+ }
}
public boolean isFull() {
@@ -160,7 +159,6 @@ public void clear() {
}
/**
- *
* Returns cache data in list form.
*/
public List
+ * The below example demonstrates basic CRUD operations: Create, Read, Update, and Delete.
+ *
+ */
+public final class App {
+
+ private static Logger log = Logger.getLogger(App.class);
+
+ /**
+ * Program entry point.
+ *
+ * @param args command line args.
+ */
+ public static void main(final String... args) {
+
+ /* Create new data mapper for type 'first' */
+ final StudentDataMapper mapper = new StudentDataMapperImpl();
+
+ /* Create new student */
+ Student student = new Student(1, "Adam", 'A');
+
+ /* Add student in respectibe store */
+ mapper.insert(student);
+
+ log.debug("App.main(), student : " + student + ", is inserted");
+
+ /* Find this student */
+ final Optional
+ */
+public class DataMapperTest {
+
+ /**
+ * This test verify that first data mapper is able to perform all CRUD operations on Student
+ */
+ @Test
+ public void testFirstDataMapper() {
+
+ /* Create new data mapper of first type */
+ final StudentDataMapper mapper = new StudentDataMapperImpl();
+
+ /* Create new student */
+ Student student = new Student(1, "Adam", 'A');
+
+ /* Add student in respectibe db */
+ mapper.insert(student);
+
+ /* Check if student is added in db */
+ assertEquals(student.getStudentId(), mapper.find(student.getStudentId()).get().getStudentId());
+
+ /* Update existing student object */
+ student = new Student(student.getStudentId(), "AdamUpdated", 'A');
+
+ /* Update student in respectibe db */
+ mapper.update(student);
+
+ /* Check if student is updated in db */
+ assertEquals(mapper.find(student.getStudentId()).get().getName(), "AdamUpdated");
+
+ /* Delete student in db */
+ mapper.delete(student);
+
+ /* Result should be false */
+ assertEquals(false, mapper.find(student.getStudentId()).isPresent());
+ }
+}
diff --git a/data-mapper/src/test/java/com/iluwatar/datamapper/StudentTest.java b/data-mapper/src/test/java/com/iluwatar/datamapper/StudentTest.java
new file mode 100644
index 000000000000..a3c0e46c1dc6
--- /dev/null
+++ b/data-mapper/src/test/java/com/iluwatar/datamapper/StudentTest.java
@@ -0,0 +1,51 @@
+/**
+ * The MIT License Copyright (c) 2016 Amit Dixit
+ *
+ * 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.
+ */
+package com.iluwatar.datamapper;
+
+import org.junit.Test;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertFalse;
+
+public final class StudentTest {
+
+ @Test
+ /**
+ * This API tests the equality behaviour of Student object
+ * Object Equality should work as per logic defined in equals method
+ *
+ * @throws Exception if any execution error during test
+ */
+ public void testEquality() throws Exception {
+
+ /* Create some students */
+ final Student firstStudent = new Student(1, "Adam", 'A');
+ final Student secondStudent = new Student(2, "Donald", 'B');
+ final Student secondSameStudent = new Student(2, "Donald", 'B');
+ final Student firstSameStudent = firstStudent;
+
+ /* Check equals functionality: should return 'true' */
+ assertTrue(firstStudent.equals(firstSameStudent));
+
+ /* Check equals functionality: should return 'false' */
+ assertFalse(firstStudent.equals(secondStudent));
+
+ /* Check equals functionality: should return 'true' */
+ assertTrue(secondStudent.equals(secondSameStudent));
+ }
+}
diff --git a/decorator/README.md b/decorator/README.md
index 63795114c798..8198734292b5 100644
--- a/decorator/README.md
+++ b/decorator/README.md
@@ -3,6 +3,7 @@ layout: pattern
title: Decorator
folder: decorator
permalink: /patterns/decorator/
+pumlid: HSV14SCm20J0Lk82BFxf1YF6LaP26ZZizfDVVhjRC-bPDRs_Bc35cyZvAMV3bKU6kao36ehCGQtdms2d3z-yLursshuOKBUWmV43LPNfZEcaaFzA-YWhH_y2
categories: Structural
tags:
- Java
@@ -27,6 +28,14 @@ Use Decorator
* for responsibilities that can be withdrawn
* when extension by subclassing is impractical. Sometimes a large number of independent extensions are possible and would produce an explosion of subclasses to support every combination. Or a class definition may be hidden or otherwise unavailable for subclassing
+## Real world examples
+ * [java.io.InputStream](http://docs.oracle.com/javase/8/docs/api/java/io/InputStream.html), [java.io.OutputStream](http://docs.oracle.com/javase/8/docs/api/java/io/OutputStream.html),
+ [java.io.Reader](http://docs.oracle.com/javase/8/docs/api/java/io/Reader.html) and [java.io.Writer](http://docs.oracle.com/javase/8/docs/api/java/io/Writer.html)
+ * [java.util.Collections#synchronizedXXX()](http://docs.oracle.com/javase/8/docs/api/java/util/Collections.html#synchronizedCollection-java.util.Collection-)
+ * [java.util.Collections#unmodifiableXXX()](http://docs.oracle.com/javase/8/docs/api/java/util/Collections.html#unmodifiableCollection-java.util.Collection-)
+ * [java.util.Collections#checkedXXX()](http://docs.oracle.com/javase/8/docs/api/java/util/Collections.html#checkedCollection-java.util.Collection-java.lang.Class-)
+
+
## Credits
* [Design Patterns: Elements of Reusable Object-Oriented Software](http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612)
diff --git a/decorator/etc/decorator.urm.puml b/decorator/etc/decorator.urm.puml
new file mode 100644
index 000000000000..4862ddfeb47f
--- /dev/null
+++ b/decorator/etc/decorator.urm.puml
@@ -0,0 +1,29 @@
+@startuml
+package com.iluwatar.decorator {
+ interface Hostile {
+ + attack() {abstract}
+ + fleeBattle() {abstract}
+ + getAttackPower() : int {abstract}
+ }
+ class App {
+ + App()
+ + main(args : String[]) {static}
+ }
+ class Troll {
+ + Troll()
+ + attack()
+ + fleeBattle()
+ + getAttackPower() : int
+ }
+ class SmartHostile {
+ - decorated : Hostile
+ + SmartHostile(decorated : Hostile)
+ + attack()
+ + fleeBattle()
+ + getAttackPower() : int
+ }
+}
+SmartHostile --> "-decorated" Hostile
+Troll ..|> Hostile
+SmartHostile ..|> Hostile
+@enduml
\ No newline at end of file
diff --git a/decorator/pom.xml b/decorator/pom.xml
index 58f2bb0bacc2..36c3eef01ab4 100644
--- a/decorator/pom.xml
+++ b/decorator/pom.xml
@@ -29,7 +29,7 @@
+ *
+ * The core logic, or business logic, of an application consists of the
+ * algorithms that are essential to its purpose. They implement the use
+ * cases that are the heart of the application. When you change them, you
+ * change the essence of the application.
+ *
+ * The services are not essential. They can be replaced without changing
+ * the purpose of the application. Examples: database access and other
+ * types of storage, user interface components, e-mail and other
+ * communication components, hardware devices.
+ *
+ * This example demonstrates Hexagonal Architecture with a lottery system.
+ * The application core is separate from the services that drive it and
+ * from the services it uses.
+ *
+ * The primary ports for the application are console interfaces
+ * {@link ConsoleAdministration} through which the lottery round is
+ * initiated and run and {@link ConsoleLottery} that allows players to
+ * submit lottery tickets for the draw.
+ *
+ * The secondary ports that application core uses are {@link WireTransfers}
+ * which is a banking service, {@link LotteryEventLog} that delivers
+ * eventlog as lottery events occur and {@link LotteryTicketRepository}
+ * that is the storage for the lottery tickets.
+ *
+ */
+public class App {
+
+ /**
+ * Program entry point
+ */
+ public static void main(String[] args) {
+
+ Injector injector = Guice.createInjector(new LotteryTestingModule());
+
+ // start new lottery round
+ LotteryAdministration administartion = injector.getInstance(LotteryAdministration.class);
+ administartion.resetLottery();
+
+ // submit some lottery tickets
+ LotteryService service = injector.getInstance(LotteryService.class);
+ SampleData.submitTickets(service, 20);
+
+ // perform lottery
+ administartion.performLottery();
+ }
+}
diff --git a/hexagonal/src/main/java/com/iluwatar/hexagonal/administration/ConsoleAdministration.java b/hexagonal/src/main/java/com/iluwatar/hexagonal/administration/ConsoleAdministration.java
new file mode 100644
index 000000000000..ea2f33699416
--- /dev/null
+++ b/hexagonal/src/main/java/com/iluwatar/hexagonal/administration/ConsoleAdministration.java
@@ -0,0 +1,86 @@
+/**
+ * The MIT License
+ * Copyright (c) 2014 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.
+ */
+package com.iluwatar.hexagonal.administration;
+
+import com.google.inject.Guice;
+import com.google.inject.Injector;
+import com.iluwatar.hexagonal.domain.LotteryAdministration;
+import com.iluwatar.hexagonal.domain.LotteryNumbers;
+import com.iluwatar.hexagonal.domain.LotteryService;
+import com.iluwatar.hexagonal.module.LotteryModule;
+import com.iluwatar.hexagonal.mongo.MongoConnectionPropertiesLoader;
+import com.iluwatar.hexagonal.sampledata.SampleData;
+
+import java.util.Scanner;
+
+/**
+ * Console interface for lottery administration
+ */
+public class ConsoleAdministration {
+
+ /**
+ * Program entry point
+ */
+ public static void main(String[] args) {
+ MongoConnectionPropertiesLoader.load();
+ Injector injector = Guice.createInjector(new LotteryModule());
+ LotteryAdministration administartion = injector.getInstance(LotteryAdministration.class);
+ LotteryService service = injector.getInstance(LotteryService.class);
+ SampleData.submitTickets(service, 20);
+ Scanner scanner = new Scanner(System.in);
+ boolean exit = false;
+ while (!exit) {
+ printMainMenu();
+ String cmd = readString(scanner);
+ if (cmd.equals("1")) {
+ administartion.getAllSubmittedTickets().forEach((k,v)->System.out.println("Key: " + k + " Value: " + v));
+ } else if (cmd.equals("2")) {
+ LotteryNumbers numbers = administartion.performLottery();
+ System.out.println("The winning numbers: " + numbers.getNumbersAsString());
+ System.out.println("Time to reset the database for next round, eh?");
+ } else if (cmd.equals("3")) {
+ administartion.resetLottery();
+ System.out.println("The lottery ticket database was cleared.");
+ } else if (cmd.equals("4")) {
+ exit = true;
+ } else {
+ System.out.println("Unknown command: " + cmd);
+ }
+ }
+ }
+
+ private static void printMainMenu() {
+ System.out.println("");
+ System.out.println("### Lottery Administration Console ###");
+ System.out.println("(1) Show all submitted tickets");
+ System.out.println("(2) Perform lottery draw");
+ System.out.println("(3) Reset lottery ticket database");
+ System.out.println("(4) Exit");
+ }
+
+ private static String readString(Scanner scanner) {
+ System.out.print("> ");
+ String cmd = scanner.next();
+ return cmd;
+ }
+}
diff --git a/hexagonal/src/main/java/com/iluwatar/hexagonal/banking/InMemoryBank.java b/hexagonal/src/main/java/com/iluwatar/hexagonal/banking/InMemoryBank.java
new file mode 100644
index 000000000000..85b4121ebc42
--- /dev/null
+++ b/hexagonal/src/main/java/com/iluwatar/hexagonal/banking/InMemoryBank.java
@@ -0,0 +1,63 @@
+/**
+ * The MIT License
+ * Copyright (c) 2014 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.
+ */
+package com.iluwatar.hexagonal.banking;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import com.iluwatar.hexagonal.domain.LotteryConstants;
+
+/**
+ *
+ * Banking implementation
+ *
+ */
+public class InMemoryBank implements WireTransfers {
+
+ private static Mapwrite-through which writes data to the cache and DB in a single transaction,
- * write-around which writes data immediately into the DB instead of the cache, and
+ * write-around which writes data immediately into the DB instead of the cache,
* write-behind which writes data into the cache initially whilst the data is only
- * written into the DB when the cache is full. The read-through strategy is also
- * included in the mentioned three strategies -- returns data from the cache to the caller if
- * it exists else queries from DB and stores it into the cache for future use. These
- * strategies determine when the data in the cache should be written back to the backing store (i.e.
- * Database) and help keep both data sources synchronized/up-to-date. This pattern can improve
- * performance and also helps to maintain consistency between data held in the cache and the data in
- * the underlying data store.
+ * written into the DB when the cache is full, and cache-aside which pushes the
+ * responsibility of keeping the data synchronized in both data sources to the application itself.
+ * The read-through strategy is also included in the mentioned four strategies --
+ * returns data from the cache to the caller if it exists else queries from DB and
+ * stores it into the cache for future use. These strategies determine when the data in the cache
+ * should be written back to the backing store (i.e. Database) and help keep both data sources
+ * synchronized/up-to-date. This pattern can improve performance and also helps to maintain
+ * consistency between data held in the cache and the data in the underlying data store.
* start, stop, getStatus. For Synchronous events, the user is unable to
+ * start another (Synchronous) event if one is already running at the time. The running event would have to either be
+ * stopped or completed before a new event can be started.
+ *
+ * The Event-based Asynchronous Pattern makes available the advantages of multithreaded applications while hiding many
+ * of the complex issues inherent in multithreaded design. Using a class that supports this pattern can allow you to:-
+ * (1) Perform time-consuming tasks, such as downloads and database operations, "in the background," without
+ * interrupting your application. (2) Execute multiple operations simultaneously, receiving notifications when each
+ * completes. (3) Wait for resources to become available without stopping ("hanging") your application. (4) Communicate
+ * with pending asynchronous operations using the familiar events-and-delegates model.
+ *
+ * @see EventManager
+ * @see Event
+ *
+ */
+public class App {
+
+ public static final String PROP_FILE_NAME = "config.properties";
+
+ boolean interactiveMode = false;
+
+ /**
+ * Program entry point.
+ *
+ * @param args command line args
+ */
+ public static void main(String[] args) {
+ App app = new App();
+
+ app.setUp();
+ app.run();
+ }
+
+ /**
+ * App can run in interactive mode or not. Interactive mode == Allow user interaction with command line.
+ * Non-interactive is a quick sequential run through the available {@link EventManager} operations.
+ */
+ public void setUp() {
+ Properties prop = new Properties();
+
+ InputStream inputStream = App.class.getClassLoader().getResourceAsStream(PROP_FILE_NAME);
+
+ if (inputStream != null) {
+ try {
+ prop.load(inputStream);
+ } catch (IOException e) {
+ System.out.println(PROP_FILE_NAME + " was not found. Defaulting to non-interactive mode.");
+ }
+ String property = prop.getProperty("INTERACTIVE_MODE");
+ if (property.equalsIgnoreCase("YES")) {
+ interactiveMode = true;
+ }
+ }
+ }
+
+ /**
+ * Run program in either interactive mode or not.
+ */
+ public void run() {
+ if (interactiveMode) {
+ runInteractiveMode();
+ } else {
+ quickRun();
+ }
+ }
+
+ /**
+ * Run program in non-interactive mode.
+ */
+ public void quickRun() {
+ EventManager eventManager = new EventManager();
+
+ try {
+ // Create an Asynchronous event.
+ int aEventId = eventManager.createAsync(60);
+ System.out.println("Async Event [" + aEventId + "] has been created.");
+ eventManager.start(aEventId);
+ System.out.println("Async Event [" + aEventId + "] has been started.");
+
+ // Create a Synchronous event.
+ int sEventId = eventManager.create(60);
+ System.out.println("Sync Event [" + sEventId + "] has been created.");
+ eventManager.start(sEventId);
+ System.out.println("Sync Event [" + sEventId + "] has been started.");
+
+ eventManager.status(aEventId);
+ eventManager.status(sEventId);
+
+ eventManager.cancel(aEventId);
+ System.out.println("Async Event [" + aEventId + "] has been stopped.");
+ eventManager.cancel(sEventId);
+ System.out.println("Sync Event [" + sEventId + "] has been stopped.");
+
+ } catch (MaxNumOfEventsAllowedException | LongRunningEventException | EventDoesNotExistException
+ | InvalidOperationException e) {
+ System.out.println(e.getMessage());
+ }
+ }
+
+ /**
+ * Run program in interactive mode.
+ */
+ public void runInteractiveMode() {
+ EventManager eventManager = new EventManager();
+
+ Scanner s = new Scanner(System.in);
+ int option = -1;
+ while (option != 4) {
+ System.out.println("Hello. Would you like to boil some eggs?");
+ System.out.println("(1) BOIL AN EGG \n(2) STOP BOILING THIS EGG \n(3) HOW ARE MY EGGS? \n(4) EXIT");
+ System.out.print("Choose [1,2,3,4]: ");
+ option = s.nextInt();
+
+ if (option == 1) {
+ s.nextLine();
+ System.out.print("Boil multiple eggs at once (A) or boil them one-by-one (S)?: ");
+ String eventType = s.nextLine();
+ System.out.print("How long should this egg be boiled for (in seconds)?: ");
+ int eventTime = s.nextInt();
+ if (eventType.equalsIgnoreCase("A")) {
+ try {
+ int eventId = eventManager.createAsync(eventTime);
+ eventManager.start(eventId);
+ System.out.println("Egg [" + eventId + "] is being boiled.");
+ } catch (MaxNumOfEventsAllowedException | LongRunningEventException | EventDoesNotExistException e) {
+ System.out.println(e.getMessage());
+ }
+ } else if (eventType.equalsIgnoreCase("S")) {
+ try {
+ int eventId = eventManager.create(eventTime);
+ eventManager.start(eventId);
+ System.out.println("Egg [" + eventId + "] is being boiled.");
+ } catch (MaxNumOfEventsAllowedException | InvalidOperationException | LongRunningEventException
+ | EventDoesNotExistException e) {
+ System.out.println(e.getMessage());
+ }
+ } else {
+ System.out.println("Unknown event type.");
+ }
+ } else if (option == 2) {
+ System.out.print("Which egg?: ");
+ int eventId = s.nextInt();
+ try {
+ eventManager.cancel(eventId);
+ System.out.println("Egg [" + eventId + "] is removed from boiler.");
+ } catch (EventDoesNotExistException e) {
+ System.out.println(e.getMessage());
+ }
+ } else if (option == 3) {
+ s.nextLine();
+ System.out.print("Just one egg (O) OR all of them (A) ?: ");
+ String eggChoice = s.nextLine();
+
+ if (eggChoice.equalsIgnoreCase("O")) {
+ System.out.print("Which egg?: ");
+ int eventId = s.nextInt();
+ try {
+ eventManager.status(eventId);
+ } catch (EventDoesNotExistException e) {
+ System.out.println(e.getMessage());
+ }
+ } else if (eggChoice.equalsIgnoreCase("A")) {
+ eventManager.statusOfAllEvents();
+ }
+ } else if (option == 4) {
+ eventManager.shutdown();
+ }
+ }
+
+ s.close();
+ }
+
+}
diff --git a/event-asynchronous/src/main/java/com/iluwatar/event/asynchronous/Event.java b/event-asynchronous/src/main/java/com/iluwatar/event/asynchronous/Event.java
new file mode 100644
index 000000000000..5e557fff2e0e
--- /dev/null
+++ b/event-asynchronous/src/main/java/com/iluwatar/event/asynchronous/Event.java
@@ -0,0 +1,101 @@
+/**
+ * The MIT License Copyright (c) 2014 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.
+ */
+package com.iluwatar.event.asynchronous;
+
+/**
+ *
+ * Each Event runs as a separate/individual thread.
+ *
+ */
+public class Event implements IEvent, Runnable {
+
+ private int eventId;
+ private int eventTime;
+ private boolean isSynchronous;
+ private Thread thread;
+ private boolean isComplete = false;
+ private ThreadCompleteListener eventListener;
+
+ /**
+ *
+ * @param eventId event ID
+ * @param eventTime event time
+ * @param isSynchronous is of synchronous type
+ */
+ public Event(final int eventId, final int eventTime, final boolean isSynchronous) {
+ this.eventId = eventId;
+ this.eventTime = eventTime;
+ this.isSynchronous = isSynchronous;
+ }
+
+ public boolean isSynchronous() {
+ return isSynchronous;
+ }
+
+ @Override
+ public void start() {
+ thread = new Thread(this);
+ thread.start();
+ }
+
+ @Override
+ public void stop() {
+ if (null == thread) {
+ return;
+ }
+ thread.interrupt();
+ }
+
+ @Override
+ public void status() {
+ if (!isComplete) {
+ System.out.println("[" + eventId + "] is not done.");
+ } else {
+ System.out.println("[" + eventId + "] is done.");
+ }
+ }
+
+ @Override
+ public void run() {
+ long currentTime = System.currentTimeMillis();
+ long endTime = currentTime + (eventTime * 1000);
+ while (System.currentTimeMillis() < endTime) {
+ try {
+ Thread.sleep(1000); // Sleep for 1 second.
+ } catch (InterruptedException e) {
+ return;
+ }
+ }
+ isComplete = true;
+ completed();
+ }
+
+ public final void addListener(final ThreadCompleteListener listener) {
+ this.eventListener = listener;
+ }
+
+ public final void removeListener(final ThreadCompleteListener listener) {
+ this.eventListener = null;
+ }
+
+ private final void completed() {
+ if (eventListener != null) {
+ eventListener.completedEventHandler(eventId);
+ }
+ }
+
+}
diff --git a/event-asynchronous/src/main/java/com/iluwatar/event/asynchronous/EventDoesNotExistException.java b/event-asynchronous/src/main/java/com/iluwatar/event/asynchronous/EventDoesNotExistException.java
new file mode 100644
index 000000000000..77c1d479bfcb
--- /dev/null
+++ b/event-asynchronous/src/main/java/com/iluwatar/event/asynchronous/EventDoesNotExistException.java
@@ -0,0 +1,26 @@
+/**
+ * The MIT License Copyright (c) 2014 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.
+ */
+package com.iluwatar.event.asynchronous;
+
+public class EventDoesNotExistException extends Exception {
+
+ private static final long serialVersionUID = -3398463738273811509L;
+
+ public EventDoesNotExistException(String message) {
+ super(message);
+ }
+}
diff --git a/event-asynchronous/src/main/java/com/iluwatar/event/asynchronous/EventManager.java b/event-asynchronous/src/main/java/com/iluwatar/event/asynchronous/EventManager.java
new file mode 100644
index 000000000000..dae995e382ab
--- /dev/null
+++ b/event-asynchronous/src/main/java/com/iluwatar/event/asynchronous/EventManager.java
@@ -0,0 +1,218 @@
+/**
+ * The MIT License Copyright (c) 2014 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.
+ */
+package com.iluwatar.event.asynchronous;
+
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Random;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ *
+ * EventManager handles and maintains a pool of event threads. {@link Event} threads are created upon user request. Thre
+ * are two types of events; Asynchronous and Synchronous. There can be multiple Asynchronous events running at once but
+ * only one Synchronous event running at a time. Currently supported event operations are: start, stop, and getStatus.
+ * Once an event is complete, it then notifies EventManager through a listener. The EventManager then takes the event
+ * out of the pool.
+ *
+ */
+public class EventManager implements ThreadCompleteListener {
+
+ public static final int MAX_RUNNING_EVENTS = 1000; // Just don't wanna have too many running events. :)
+ public static final int MIN_ID = 1;
+ public static final int MAX_ID = MAX_RUNNING_EVENTS;
+ public static final int MAX_EVENT_TIME = 1800; // in seconds / 30 minutes.
+ private int currentlyRunningSyncEvent = -1;
+ private Random rand;
+ private MapInteger.MAX_VALUE - 1.
+ */
+ private int generateId() {
+ // nextInt is normally exclusive of the top value,
+ // so add 1 to make it inclusive
+ int randomNum = rand.nextInt((MAX_ID - MIN_ID) + 1) + MIN_ID;
+ while (eventPool.containsKey(randomNum)) {
+ randomNum = rand.nextInt((MAX_ID - MIN_ID) + 1) + MIN_ID;
+ }
+
+ return randomNum;
+ }
+
+ /**
+ * Callback from an {@link Event} (once it is complete). The Event is then removed from the pool.
+ */
+ @Override
+ public void completedEventHandler(int eventId) {
+ eventPool.get(eventId).status();
+ if (eventPool.get(eventId).isSynchronous()) {
+ currentlyRunningSyncEvent = -1;
+ }
+ eventPool.remove(eventId);
+ }
+
+ /**
+ * Getter method for event pool.
+ */
+ public Map