From a75de10d8ddafe5b26d8784369c54e732ed97885 Mon Sep 17 00:00:00 2001 From: Miroslav Trninic Date: Mon, 29 Mar 2021 18:58:35 +0200 Subject: [PATCH 1/8] Mon 29 Mar 2021 06:58:35 PM CEST --- mvnw | 0 patterns.md | 14070 ++++++++++++++++ .../specialcase/InsufficientFunds.java~merged | 67 + 3 files changed, 14137 insertions(+) mode change 100755 => 100644 mvnw create mode 100644 patterns.md create mode 100644 special-case/src/main/java/com/iluwatar/specialcase/InsufficientFunds.java~merged diff --git a/mvnw b/mvnw old mode 100755 new mode 100644 diff --git a/patterns.md b/patterns.md new file mode 100644 index 000000000000..e1d26a9cf081 --- /dev/null +++ b/patterns.md @@ -0,0 +1,14070 @@ +# Java design patterns + +## Content +[1. Abstract Document](#abstract-document) + +[2. Abstract Factory](#abstract-factory) + +[3. Acyclic Visitor](#acyclic-visitor) + +[4. Adapter](#adapter) + +[5. Aggregator Microservices](#aggregator-microservices) + +[6. Ambassaddor](#ambassador) + +[7. Api Gatway](#api-gateway) + +[8. Arrange/Act/Assert](#arrangeactassert) + +[9. Async Method Invocation](#async-method-invocation) + +[10. Balking](#balking) + +[11. Bridge](#bridge) + +[12. Builder](#builder) + +[13. Business Delegete](#business-delegate) + +[14. Bytecode](#bytecode) + +[15. Caching](#caching) + +[16. Callback](#callback) + +[17. Chain of Responsibility](#chain-of-responsibility) + +[18. Circuit Breaker](#circuit-breaker) + +[19. Collection Pipeline](#collection-pipelline) + +[20. Combinator](#combinator) + +[21. Command](#command) + +[22. Commander](#commander) + +[23. Composite](#composite) + +[24. Converter](#converter) + +[25. CQRS](#cqrs) + +[26. DAO](#DAO) + +[27. Data Bus](#data-bus) + +[28. Data Locality](#data-locality) + +[29. Data Mapper](#data-mapper) + +[30. Data Transfer Object](#data-transfer-object) + +[31. Decorator](#decorator) + +[32. Delegation](#delegation) + +[33. Dependency Injection](#dependency-injection) + +[34. Dirty Flag](#dirty-flag) + +[35. Double Buffer](#double-buffer) + +[36. Double Checked Locking](#double-checked-locking) + +[37. Double Dispatch](#double-dispatch) + +[38. EIP Aggregator](#eip-aggregator) + +[39. EIP Message Channel](#eip-message-channel) + +[40. EIP Publish Subscribe](#eip-publish-subscribe) + +[41. EIP Splitter](#eip-splitter) + +[42. EIP Wire Tap](#eip-wire-tap) + +[43. Event Aggregator](#event-aggregator) + +[44. Event Asynchronous](#event-asynchronous) + +[45. Event Driven Architecture](#event-driven-architecture) + +[46. Event Queue](#event-queue) + +[47. Event Sourcing](#event-sourcing) + +[48. Execute Around](#execute-around) + +[49. Extension Objects](#extension-objects) + +[50. Facade](#facade) + +[51. Factory](#factory) + +[52. Factory Kit](#factory-kit) + +[53. Factory Method](#factory-method) + +[54. Feature Toogle](#feature-toggle) + +[55. Filterer](#filterer) + +[56. Fluent Interface](#fluent-interface) + +[57. Flux](#flux) + +[58. Flyweight](#flyweight) + +[59. Front Controller](#front-controller) + +[60. Game Loop](#game-loop) + +[61. Guarded Suspension](#guarded-suspension) + +[62. Half Sync Half Async](#half-synchalf-async) + +[63. Hexagonal Architecture](#hexagonal-architecture) + +[64. Intercepting Filter](#intercepting-filter) + +[65. Interpreter](#interpreter) + +[66. Iterator](#iterator) + +[67. Layers](#layers) + +[68. Lazy Loading](#lazy-loading) + +[69. Leader Election](#leader-election) + +[70. Leader Followers](#leader-followers) + +[71. Marker Interface](#marker-interface) + +[72. Master Worker](#master-worker) + +[73. Mediator](#mediator) + +[74. Memento](#memento) + +[75. Model View Controller](#model-view-controller) + +[76. Model View Presenter](#model-view-presenter) + +[77. Module](#module) + +[78. Monad](#monad) + +[79. Monostate](#monostate) + +[80. Multiton](#multiton) + +[81. Mute Idiom](#mute-idiom) + +[82. Naked Objects](#naked-objects) + +[83. Null Object](#null-object) + +[84. Object Mother](#object-mother) + +[85. Object Pool](#object-pool) + +[86. Observer](#observer) + +[87. Page Object](#page-object) + +[88. Partial Response](#partial-response) + +[89. Pipeline](#pipeline) + +[90. Poison Pill](#poison-pill) + +[91. Priority Queue](#priority-queue-pattern) + +[92. Private Class Data](#private-class-data) + +[93. Producer Consumer](#producer-consumer) + +[94. Promise](#promise) + +[95. Property](#property) + +[96. Prototype](#prototype) + +[97. Proxy](#proxy) + +[98. Queue Load Leveling](#queue-based-load-leveling) + +[99. Reactor](#reactor) + +[100. Reder Writer Lock](#reader-writer-lock) + +[101. Registry](#registry) + +[102. Repository](#repository) + +[103. Resource Acquisition Is Initialization](#resource-acquisition-is-initialization) + +[104. Retry](#retry) + +[105. Role Object](#role-object) + +[106. Saga](#saga) + +[107. Separated Interface](#separated-interface) + +[108. Servant](#servant) + +[109. Serverless](#serverless) + +[110. Service Layer](#service-layer) + +[111. Service Locator](#service-locator) + +[112. Sharding](#sharding) + +[113. Singleton](#singleton) + +[114. Spatial Partition](#spatial-partition) + +[115. Special Case](#special-case) + +[116. Specification](#specification) + +[117. State](#state) + +[118. Step Builder](#step-builder) + +[119. Strangler](#strangler) + +[120. Strategy](#strategy) + +[121. Subclass Sandbox](#subclass-sandbox) + +[122. Template Method](#template-method) + +[123. Thread Pool](#thread-pool) + +[124. Throttling](#throttling) + +[125. Thread Local Storage](#thread-local-storage) + +[126. Tolerant Reader](#tolerant-reader) + +[127. Trampoline](#trampoline) + +[128. Transaction Script](#transaction-script) + +[129. Twin](#twin) + +[130. Type Object Pattern](#type-object-pattern) + +[131. Unit of Work](#unit-of-work) + +[132. Update Method](#update-method) + +[133. Value Object](#value-object) + +[134. Version Number](#version-number) + +[135. Visitor](#visitor) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +--- +## Abstract Document +[⬆](#content) + + +--- +layout: pattern +title: Abstract Document +folder: abstract-document +permalink: /patterns/abstract-document/ +categories: Structural +tags: + - Extensibility +--- + +### Intent + +Use dynamic properties and achieve flexibility of untyped languages while keeping type-safety. + +### Explanation + +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. + +Real world example + +> Consider a car that consists of multiple parts. However we don't know if the specific car really has all the parts, or just some of them. Our cars are dynamic and extremely flexible. + +In plain words + +> Abstract Document pattern allows attaching properties to objects without them knowing about it. + +Wikipedia says + +> An object-oriented structural design pattern for organizing objects in loosely typed key-value stores and exposing +the data using typed views. The purpose of the pattern is to achieve a high degree of flexibility between components +in a strongly typed language where new properties can be added to the object-tree on the fly, without losing the +support of type-safety. The pattern makes use of traits to separate different properties of a class into different +interfaces. + +**Programmatic Example** + +Let's first define the base classes `Document` and `AbstractDocument`. They basically make the object hold a property +map and any amount of child objects. + +```java +public interface Document { + + Void put(String key, Object value); + + Object get(String key); + + Stream children(String key, Function, T> constructor); +} + +public abstract class AbstractDocument implements Document { + + private final Map properties; + + protected AbstractDocument(Map properties) { + Objects.requireNonNull(properties, "properties map is required"); + this.properties = properties; + } + + @Override + public Void put(String key, Object value) { + properties.put(key, value); + return null; + } + + @Override + public Object get(String key) { + return properties.get(key); + } + + @Override + public Stream children(String key, Function, T> constructor) { + return Stream.ofNullable(get(key)) + .filter(Objects::nonNull) + .map(el -> (List>) el) + .findAny() + .stream() + .flatMap(Collection::stream) + .map(constructor); + } + ... +} +``` +Next we define an enum `Property` and a set of interfaces for type, price, model and parts. This allows us to create +static looking interface to our `Car` class. + +```java +public enum Property { + + PARTS, TYPE, PRICE, MODEL +} + +public interface HasType extends Document { + + default Optional getType() { + return Optional.ofNullable((String) get(Property.TYPE.toString())); + } +} + +public interface HasPrice extends Document { + + default Optional getPrice() { + return Optional.ofNullable((Number) get(Property.PRICE.toString())); + } +} +public interface HasModel extends Document { + + default Optional getModel() { + return Optional.ofNullable((String) get(Property.MODEL.toString())); + } +} + +public interface HasParts extends Document { + + default Stream getParts() { + return children(Property.PARTS.toString(), Part::new); + } +} +``` + +Now we are ready to introduce the `Car`. + +```java +public class Car extends AbstractDocument implements HasModel, HasPrice, HasParts { + + public Car(Map properties) { + super(properties); + } +} +``` + +And finally here's how we construct and use the `Car` in a full example. + +```java + LOGGER.info("Constructing parts and car"); + + var wheelProperties = Map.of( + Property.TYPE.toString(), "wheel", + Property.MODEL.toString(), "15C", + Property.PRICE.toString(), 100L); + + var doorProperties = Map.of( + Property.TYPE.toString(), "door", + Property.MODEL.toString(), "Lambo", + Property.PRICE.toString(), 300L); + + var carProperties = Map.of( + Property.MODEL.toString(), "300SL", + Property.PRICE.toString(), 10000L, + Property.PARTS.toString(), List.of(wheelProperties, doorProperties)); + + var car = new Car(carProperties); + + LOGGER.info("Here is our car:"); + LOGGER.info("-> model: {}", car.getModel().orElseThrow()); + LOGGER.info("-> price: {}", car.getPrice().orElseThrow()); + LOGGER.info("-> parts: "); + car.getParts().forEach(p -> LOGGER.info("\t{}/{}/{}", + p.getType().orElse(null), + p.getModel().orElse(null), + p.getPrice().orElse(null)) + ); + + // Constructing parts and car + // Here is our car: + // model: 300SL + // price: 10000 + // parts: + // wheel/15C/100 + // door/Lambo/300 +``` + +### Class diagram + +![alt text](./etc/abstract-document.png "Abstract Document Traits and Domain") + +### Applicability + +Use the Abstract Document Pattern when + +* There is a need to add new properties on the fly +* You want a flexible way to organize domain in tree like structure +* You want more loosely coupled system + +### Credits + +* [Wikipedia: Abstract Document Pattern](https://en.wikipedia.org/wiki/Abstract_Document_Pattern) +* [Martin Fowler: Dealing with properties](http://martinfowler.com/apsupp/properties.pdf) +* [Pattern-Oriented Software Architecture Volume 4: A Pattern Language for Distributed Computing (v. 4)](https://www.amazon.com/gp/product/0470059028/ref=as_li_qf_asin_il_tl?ie=UTF8&tag=javadesignpat-20&creative=9325&linkCode=as2&creativeASIN=0470059028&linkId=e3aacaea7017258acf184f9f3283b492) + + +## Abstract Factory +[⬆](#content) + +--- +layout: pattern +title: Abstract Factory +folder: abstract-factory +permalink: /patterns/abstract-factory/ +categories: Creational +tags: + - Gang of Four +--- + +### Also known as + +Kit + +### Intent + +Provide an interface for creating families of related or dependent +objects without specifying their concrete classes. + +### Explanation + +Real world example + +> To create a kingdom we need objects with a common theme. Elven kingdom needs an Elven king, Elven castle and Elven army whereas Orcish kingdom needs an Orcish king, Orcish castle and Orcish army. There is a dependency between the objects in the kingdom. + +In plain words + +> A factory of factories; a factory that groups the individual but related/dependent factories together without specifying their concrete classes. + +Wikipedia says + +> The abstract factory pattern provides a way to encapsulate a group of individual factories that have a common theme without specifying their concrete classes + +**Programmatic Example** + +Translating the kingdom example above. First of all we have some interfaces and implementation for the objects in the +kingdom. + +```java +public interface Castle { + String getDescription(); +} + +public interface King { + String getDescription(); +} + +public interface Army { + String getDescription(); +} + +// Elven implementations -> +public class ElfCastle implements Castle { + static final String DESCRIPTION = "This is the Elven castle!"; + @Override + public String getDescription() { + return DESCRIPTION; + } +} +public class ElfKing implements King { + static final String DESCRIPTION = "This is the Elven king!"; + @Override + public String getDescription() { + return DESCRIPTION; + } +} +public class ElfArmy implements Army { + static final String DESCRIPTION = "This is the Elven Army!"; + @Override + public String getDescription() { + return DESCRIPTION; + } +} + +// Orcish implementations similarly -> ... + +``` + +Then we have the abstraction and implementations for the kingdom factory + +```java +public interface KingdomFactory { + Castle createCastle(); + King createKing(); + Army createArmy(); +} + +public class ElfKingdomFactory implements KingdomFactory { + public Castle createCastle() { + return new ElfCastle(); + } + public King createKing() { + return new ElfKing(); + } + public Army createArmy() { + return new ElfArmy(); + } +} + +public class OrcKingdomFactory implements KingdomFactory { + public Castle createCastle() { + return new OrcCastle(); + } + public King createKing() { + return new OrcKing(); + } + public Army createArmy() { + return new OrcArmy(); + } +} +``` + +Now we have our abstract factory that lets us make family of related objects i.e. Elven kingdom factory creates Elven castle, king and army etc. + +```java +var factory = new ElfKingdomFactory(); +var castle = factory.createCastle(); +var king = factory.createKing(); +var army = factory.createArmy(); + +castle.getDescription(); +king.getDescription(); +army.getDescription(); +``` + +Program output: + +```java +This is the Elven castle! +This is the Elven king! +This is the Elven Army! +``` + +Now, we can design a factory for our different kingdom factories. In this example, we created FactoryMaker, responsible for returning an instance of either ElfKingdomFactory or OrcKingdomFactory. +The client can use FactoryMaker to create the desired concrete factory which, in turn, will produce different concrete objects (Army, King, Castle). +In this example, we also used an enum to parameterize which type of kingdom factory the client will ask for. + +```java +public static class FactoryMaker { + + public enum KingdomType { + ELF, ORC + } + + public static KingdomFactory makeFactory(KingdomType type) { + switch (type) { + case ELF: + return new ElfKingdomFactory(); + case ORC: + return new OrcKingdomFactory(); + default: + throw new IllegalArgumentException("KingdomType not supported."); + } + } +} + +public static void main(String[] args) { + var app = new App(); + + LOGGER.info("Elf Kingdom"); + app.createKingdom(FactoryMaker.makeFactory(KingdomType.ELF)); + LOGGER.info(app.getArmy().getDescription()); + LOGGER.info(app.getCastle().getDescription()); + LOGGER.info(app.getKing().getDescription()); + + LOGGER.info("Orc Kingdom"); + app.createKingdom(FactoryMaker.makeFactory(KingdomType.ORC)); + -- similar use of the orc factory +} +``` + +### Class diagram + +![alt text](./etc/abstract-factory.urm.png "Abstract Factory class diagram") + + +### Applicability + +Use the Abstract Factory pattern when + +* The system should be independent of how its products are created, composed and represented +* The system should be configured with one of multiple families of products +* The family of related product objects is designed to be used together, and you need to enforce this constraint +* You want to provide a class library of products, and you want to reveal just their interfaces, not their implementations +* The lifetime of the dependency is conceptually shorter than the lifetime of the consumer. +* You need a run-time value to construct a particular dependency +* You want to decide which product to call from a family at runtime. +* You need to supply one or more parameters only known at run-time before you can resolve a dependency. +* When you need consistency among products +* You don’t want to change existing code when adding new products or families of products to the program. + +### Example use cases + +* Selecting to call to the appropriate implementation of FileSystemAcmeService or DatabaseAcmeService or NetworkAcmeService at runtime. +* Unit test case writing becomes much easier +* UI tools for different OS + +### Consequences + +* Dependency injection in java hides the service class dependencies that can lead to runtime errors that would have been caught at compile time. +* While the pattern is great when creating predefined objects, adding the new ones might be challenging. +* The code becomes more complicated than it should be, since a lot of new interfaces and classes are introduced along with the pattern. + +### Tutorial + +* [Abstract Factory Pattern Tutorial](https://www.journaldev.com/1418/abstract-factory-design-pattern-in-java) + +### Known uses + +* [javax.xml.parsers.DocumentBuilderFactory](http://docs.oracle.com/javase/8/docs/api/javax/xml/parsers/DocumentBuilderFactory.html) +* [javax.xml.transform.TransformerFactory](http://docs.oracle.com/javase/8/docs/api/javax/xml/transform/TransformerFactory.html#newInstance--) +* [javax.xml.xpath.XPathFactory](http://docs.oracle.com/javase/8/docs/api/javax/xml/xpath/XPathFactory.html#newInstance--) + +### Related patterns + +[Factory Method](https://java-design-patterns.com/patterns/factory-method/) +[Factory Kit](https://java-design-patterns.com/patterns/factory-kit/) + +### Credits + +* [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/gp/product/0201633612/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0201633612&linkCode=as2&tag=javadesignpat-20&linkId=675d49790ce11db99d90bde47f1aeb59) +* [Head First Design Patterns: A Brain-Friendly Guide](https://www.amazon.com/gp/product/0596007124/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596007124&linkCode=as2&tag=javadesignpat-20&linkId=6b8b6eea86021af6c8e3cd3fc382cb5b) + + +## Acyclic Visitor +[⬆](#content) + +--- +layout: pattern +title: Acyclic Visitor +folder: acyclic-visitor +permalink: /patterns/acyclic-visitor/ +categories: Behavioral +tags: + - Extensibility +--- + +### Intent + +Allow new functions to be added to existing class hierarchies without affecting those hierarchies, and without creating +the troublesome dependency cycles that are inherent to the GoF Visitor Pattern. + +### Explanation + +Real world example + +> We have a hierarchy of modem classes. The modems in this hierarchy need to be visited by an external algorithm based +> on filtering criteria (is it Unix or DOS compatible modem). + +In plain words + +> Acyclic Visitor allows functions to be added to existing class hierarchies without modifying the hierarchies. + +[WikiWikiWeb](https://wiki.c2.com/?AcyclicVisitor) says + +> The Acyclic Visitor pattern allows new functions to be added to existing class hierarchies without affecting those +> hierarchies, and without creating the dependency cycles that are inherent to the GangOfFour VisitorPattern. + +**Programmatic Example** + +Here's the `Modem` hierarchy. + +```java +public abstract class Modem { + public abstract void accept(ModemVisitor modemVisitor); +} + +public class Zoom extends Modem { + ... + @Override + public void accept(ModemVisitor modemVisitor) { + if (modemVisitor instanceof ZoomVisitor) { + ((ZoomVisitor) modemVisitor).visit(this); + } else { + LOGGER.info("Only ZoomVisitor is allowed to visit Zoom modem"); + } + } +} + +public class Hayes extends Modem { + ... + @Override + public void accept(ModemVisitor modemVisitor) { + if (modemVisitor instanceof HayesVisitor) { + ((HayesVisitor) modemVisitor).visit(this); + } else { + LOGGER.info("Only HayesVisitor is allowed to visit Hayes modem"); + } + } +} +``` + +Next we introduce the `ModemVisitor` hierarchy. + +```java +public interface ModemVisitor { +} + +public interface HayesVisitor extends ModemVisitor { + void visit(Hayes hayes); +} + +public interface ZoomVisitor extends ModemVisitor { + void visit(Zoom zoom); +} + +public interface AllModemVisitor extends ZoomVisitor, HayesVisitor { +} + +public class ConfigureForDosVisitor implements AllModemVisitor { + ... + @Override + public void visit(Hayes hayes) { + LOGGER.info(hayes + " used with Dos configurator."); + } + @Override + public void visit(Zoom zoom) { + LOGGER.info(zoom + " used with Dos configurator."); + } +} + +public class ConfigureForUnixVisitor implements ZoomVisitor { + ... + @Override + public void visit(Zoom zoom) { + LOGGER.info(zoom + " used with Unix configurator."); + } +} +``` + +Finally, here are the visitors in action. + +```java + var conUnix = new ConfigureForUnixVisitor(); + var conDos = new ConfigureForDosVisitor(); + var zoom = new Zoom(); + var hayes = new Hayes(); + hayes.accept(conDos); + zoom.accept(conDos); + hayes.accept(conUnix); + zoom.accept(conUnix); +``` + +Program output: + +``` + // Hayes modem used with Dos configurator. + // Zoom modem used with Dos configurator. + // Only HayesVisitor is allowed to visit Hayes modem + // Zoom modem used with Unix configurator. +``` + +### Class diagram + +![alt text](./etc/acyclic-visitor.png "Acyclic Visitor") + +### Applicability + +This pattern can be used: + +* When you need to add a new function to an existing hierarchy without the need to alter or affect that hierarchy. +* When there are functions that operate upon a hierarchy, but which do not belong in the hierarchy itself. e.g. the ConfigureForDOS / ConfigureForUnix / ConfigureForX issue. +* When you need to perform very different operations on an object depending upon its type. +* When the visited class hierarchy will be frequently extended with new derivatives of the Element class. +* When the recompilation, relinking, retesting or redistribution of the derivatives of Element is very expensive. + +### Consequences + +The good: + +* No dependency cycles between class hierarchies. +* No need to recompile all the visitors if a new one is added. +* Does not cause compilation failure in existing visitors if class hierarchy has a new member. + +The bad: + +* Violates [Liskov's Substitution Principle](https://java-design-patterns.com/principles/#liskov-substitution-principle) by showing that it can accept all visitors but actually only being interested in particular visitors. +* Parallel hierarchy of visitors has to be created for all members in visitable class hierarchy. + +### Related patterns + +* [Visitor Pattern](https://java-design-patterns.com/patterns/visitor/) + +### Credits + +* [Acyclic Visitor by Robert C. Martin](http://condor.depaul.edu/dmumaugh/OOT/Design-Principles/acv.pdf) +* [Acyclic Visitor in WikiWikiWeb](https://wiki.c2.com/?AcyclicVisitor) + + +## Adapter +[⬆](#content) + +--- +layout: pattern +title: Adapter +folder: adapter +permalink: /patterns/adapter/ +categories: Structural +tags: + - Gang of Four +--- + +### Also known as +Wrapper + +### Intent +Convert the interface of a class into another interface the clients expect. Adapter lets classes work together that +couldn't otherwise because of incompatible interfaces. + +### Explanation + +Real world example + +> Consider that you have some pictures in your memory card and you need to transfer them to your computer. In order to transfer them you need some kind of adapter that is compatible with your computer ports so that you can attach memory card to your computer. In this case card reader is an adapter. +> Another example would be the famous power adapter; a three legged plug can't be connected to a two pronged outlet, it needs to use a power adapter that makes it compatible with the two pronged outlet. +> Yet another example would be a translator translating words spoken by one person to another + +In plain words + +> Adapter pattern lets you wrap an otherwise incompatible object in an adapter to make it compatible with another class. + +Wikipedia says + +> In software engineering, the adapter pattern is a software design pattern that allows the interface of an existing class to be used as another interface. It is often used to make existing classes work with others without modifying their source code. + +**Programmatic Example** + +Consider a captain that can only use rowing boats and cannot sail at all. + +First we have interfaces `RowingBoat` and `FishingBoat` + +```java +public interface RowingBoat { + void row(); +} + +public class FishingBoat { + private static final Logger LOGGER = LoggerFactory.getLogger(FishingBoat.class); + public void sail() { + LOGGER.info("The fishing boat is sailing"); + } +} +``` + +And captain expects an implementation of `RowingBoat` interface to be able to move + +```java +public class Captain { + + private final RowingBoat rowingBoat; + // default constructor and setter for rowingBoat + public Captain(RowingBoat rowingBoat) { + this.rowingBoat = rowingBoat; + } + + public void row() { + rowingBoat.row(); + } +} +``` + +Now let's say the pirates are coming and our captain needs to escape but there is only fishing boat available. We need to create an adapter that allows the captain to operate the fishing boat with his rowing boat skills. + +```java +public class FishingBoatAdapter implements RowingBoat { + + private static final Logger LOGGER = LoggerFactory.getLogger(FishingBoatAdapter.class); + + private final FishingBoat boat; + + public FishingBoatAdapter() { + boat = new FishingBoat(); + } + + @Override + public void row() { + boat.sail(); + } +} +``` + +And now the `Captain` can use the `FishingBoat` to escape the pirates. + +```java +var captain = new Captain(new FishingBoatAdapter()); +captain.row(); +``` + +### Class diagram +![alt text](./etc/adapter.urm.png "Adapter class diagram") + +### Applicability +Use the Adapter pattern when + +* you want to use an existing class, and its interface does not match the one you need +* you want to create a reusable class that cooperates with unrelated or unforeseen classes, that is, classes that don't necessarily have compatible interfaces +* you need to use several existing subclasses, but it's impractical to adapt their interface by subclassing every one. An object adapter can adapt the interface of its parent class. +* most of the applications using third party libraries use adapters as a middle layer between the application and the 3rd party library to decouple the application from the library. If another library has to be used only an adapter for the new library is required without having to change the application code. + +### Consequences +Class and object adapters have different trade-offs. A class adapter + +* adapts Adaptee to Target by committing to a concrete Adaptee class. As a consequence, a class adapter won’t work when we want to adapt a class and all its subclasses. +* let’s Adapter override some of Adaptee’s behavior, since Adapter is a subclass of Adaptee. +* introduces only one object, and no additional pointer indirection is needed to get to the adaptee. + +An object adapter + +* let’s a single Adapter work with many Adaptees—that is, the Adaptee itself and all of its subclasses (if any). The Adapter can also add functionality to all Adaptees at once. +* makes it harder to override Adaptee behavior. It will require subclassing Adaptee and making Adapter refer to the subclass rather than the Adaptee itself. + + +## Real world examples + +* [java.util.Arrays#asList()](http://docs.oracle.com/javase/8/docs/api/java/util/Arrays.html#asList%28T...%29) +* [java.util.Collections#list()](https://docs.oracle.com/javase/8/docs/api/java/util/Collections.html#list-java.util.Enumeration-) +* [java.util.Collections#enumeration()](https://docs.oracle.com/javase/8/docs/api/java/util/Collections.html#enumeration-java.util.Collection-) +* [javax.xml.bind.annotation.adapters.XMLAdapter](http://docs.oracle.com/javase/8/docs/api/javax/xml/bind/annotation/adapters/XmlAdapter.html#marshal-BoundType-) + + +### Credits + +* [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/gp/product/0201633612/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0201633612&linkCode=as2&tag=javadesignpat-20&linkId=675d49790ce11db99d90bde47f1aeb59) +* [J2EE Design Patterns](https://www.amazon.com/gp/product/0596004273/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596004273&linkCode=as2&tag=javadesignpat-20&linkId=48d37c67fb3d845b802fa9b619ad8f31) +* [Head First Design Patterns: A Brain-Friendly Guide](https://www.amazon.com/gp/product/0596007124/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596007124&linkCode=as2&tag=javadesignpat-20&linkId=6b8b6eea86021af6c8e3cd3fc382cb5b) +* [Refactoring to Patterns](https://www.amazon.com/gp/product/0321213351/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0321213351&linkCode=as2&tag=javadesignpat-20&linkId=2a76fcb387234bc71b1c61150b3cc3a7) + + +## Aggregator Microservices +[⬆](#content) + +--- +layout: pattern +title: Aggregator Microservices +folder: aggregator-microservices +permalink: /patterns/aggregator-microservices/ +categories: Architectural +tags: +- Cloud distributed +- Decoupling +- Microservices +--- + +### Intent + +The user makes a single call to the aggregator service, and the aggregator then calls each relevant microservice. + +### Explanation + +Real world example + +> Our web marketplace needs information about products and their current inventory. It makes a call to an aggregator +> service which in turn calls the product information microservice and product inventory microservice returning the +> combined information. + +In plain words + +> Aggregator Microservice collects pieces of data from various microservices and returns an aggregate for processing. + +Stack Overflow says + +> Aggregator Microservice invokes multiple services to achieve the functionality required by the application. + +**Programmatic Example** + +Let's start from the data model. Here's our `Product`. + +```java +public class Product { + private String title; + private int productInventories; + // getters and setters -> + ... +} +``` + +Next we can introduce our `Aggregator` microservice. It contains clients `ProductInformationClient` and +`ProductInventoryClient` for calling respective microservices. + +```java +@RestController +public class Aggregator { + + @Resource + private ProductInformationClient informationClient; + + @Resource + private ProductInventoryClient inventoryClient; + + @RequestMapping(path = "/product", method = RequestMethod.GET) + public Product getProduct() { + + var product = new Product(); + var productTitle = informationClient.getProductTitle(); + var productInventory = inventoryClient.getProductInventories(); + + //Fallback to error message + product.setTitle(requireNonNullElse(productTitle, "Error: Fetching Product Title Failed")); + + //Fallback to default error inventory + product.setProductInventories(requireNonNullElse(productInventory, -1)); + + return product; + } +} +``` + +Here's the essence of information microservice implementation. Inventory microservice is similar, it just returns +inventory counts. + +```java +@RestController +public class InformationController { + @RequestMapping(value = "/information", method = RequestMethod.GET) + public String getProductTitle() { + return "The Product Title."; + } +} +``` + +Now calling our `Aggregator` REST API returns the product information. + +```bash +curl http://localhost:50004/product +{"title":"The Product Title.","productInventories":5} +``` + +### Class diagram + +![alt text](./aggregator-service/etc/aggregator-service.png "Aggregator Microservice") + +### Applicability + +Use the Aggregator Microservices pattern when you need a unified API for various microservices, regardless the client device. + +### Credits + +* [Microservice Design Patterns](http://web.archive.org/web/20190705163602/http://blog.arungupta.me/microservice-design-patterns/) +* [Microservices Patterns: With examples in Java](https://www.amazon.com/gp/product/1617294543/ref=as_li_qf_asin_il_tl?ie=UTF8&tag=javadesignpat-20&creative=9325&linkCode=as2&creativeASIN=1617294543&linkId=8b4e570267bc5fb8b8189917b461dc60) +* [Architectural Patterns: Uncover essential patterns in the most indispensable realm of enterprise architecture](https://www.amazon.com/gp/product/B077T7V8RC/ref=as_li_qf_asin_il_tl?ie=UTF8&tag=javadesignpat-20&creative=9325&linkCode=as2&creativeASIN=B077T7V8RC&linkId=c34d204bfe1b277914b420189f09c1a4) + +## Ambassador +[⬆](#content) + +--- +layout: pattern +title: Ambassador +folder: ambassador +permalink: /patterns/ambassador/ +categories: Structural +tags: + - Decoupling + - Cloud distributed +--- + +### Intent + +Provide a helper service instance on a client and offload common functionality away from a shared resource. + +### Explanation + +Real world example + +> A remote service has many clients accessing a function it provides. The service is a legacy application and is +> impossible to update. Large numbers of requests from users are causing connectivity issues. New rules for request +> frequency should be implemented along with latency checks and client-side logging. + +In plain words + +> With the Ambassador pattern, we can implement less-frequent polling from clients along with latency checks and +> logging. + +Microsoft documentation states + +> An ambassador service can be thought of as an out-of-process proxy which is co-located with the client. This pattern +> can be useful for offloading common client connectivity tasks such as monitoring, logging, routing, +> security (such as TLS), and resiliency patterns in a language agnostic way. It is often used with legacy applications, +> or other applications that are difficult to modify, in order to extend their networking capabilities. It can also +> enable a specialized team to implement those features. + +**Programmatic Example** + +With the above introduction in mind we will imitate the functionality in this example. We have an interface implemented +by the remote service as well as the ambassador service: + +```java +interface RemoteServiceInterface { + long doRemoteFunction(int value) throws Exception; +} +``` + +A remote services represented as a singleton. + +```java +public class RemoteService implements RemoteServiceInterface { + + private static final Logger LOGGER = LoggerFactory.getLogger(RemoteService.class); + private static RemoteService service = null; + + static synchronized RemoteService getRemoteService() { + if (service == null) { + service = new RemoteService(); + } + return service; + } + + private RemoteService() {} + + @Override + public long doRemoteFunction(int value) { + long waitTime = (long) Math.floor(Math.random() * 1000); + + try { + sleep(waitTime); + } catch (InterruptedException e) { + LOGGER.error("Thread sleep interrupted", e); + } + + return waitTime >= 200 ? value * 10 : -1; + } +} +``` + +A service ambassador adding additional features such as logging, latency checks + +```java +public class ServiceAmbassador implements RemoteServiceInterface { + + private static final Logger LOGGER = LoggerFactory.getLogger(ServiceAmbassador.class); + private static final int RETRIES = 3; + private static final int DELAY_MS = 3000; + + ServiceAmbassador() { + } + + @Override + public long doRemoteFunction(int value) { + return safeCall(value); + } + + private long checkLatency(int value) { + var startTime = System.currentTimeMillis(); + var result = RemoteService.getRemoteService().doRemoteFunction(value); + var timeTaken = System.currentTimeMillis() - startTime; + + LOGGER.info("Time taken (ms): " + timeTaken); + return result; + } + + private long safeCall(int value) { + var retries = 0; + var result = (long) FAILURE; + + for (int i = 0; i < RETRIES; i++) { + if (retries >= RETRIES) { + return FAILURE; + } + + if ((result = checkLatency(value)) == FAILURE) { + LOGGER.info("Failed to reach remote: (" + (i + 1) + ")"); + retries++; + try { + sleep(DELAY_MS); + } catch (InterruptedException e) { + LOGGER.error("Thread sleep state interrupted", e); + } + } else { + break; + } + } + return result; + } +} +``` + +A client has a local service ambassador used to interact with the remote service: + +```java +public class Client { + + private static final Logger LOGGER = LoggerFactory.getLogger(Client.class); + private final ServiceAmbassador serviceAmbassador = new ServiceAmbassador(); + + long useService(int value) { + var result = serviceAmbassador.doRemoteFunction(value); + LOGGER.info("Service result: " + result); + return result; + } +} +``` + +Here are two clients using the service. + +```java +public class App { + public static void main(String[] args) { + var host1 = new Client(); + var host2 = new Client(); + host1.useService(12); + host2.useService(73); + } +} +``` + +Here's the output for running the example: + +```java +Time taken (ms): 111 +Service result: 120 +Time taken (ms): 931 +Failed to reach remote: (1) +Time taken (ms): 665 +Failed to reach remote: (2) +Time taken (ms): 538 +Failed to reach remote: (3) +Service result: -1 +``` + +### Class diagram + +![alt text](./etc/ambassador.urm.png "Ambassador class diagram") + +### Applicability + +Ambassador is applicable when working with a legacy remote service which cannot be modified or would be extremely +difficult to modify. Connectivity features can be implemented on the client avoiding the need for changes on the remote +service. + +* Ambassador provides a local interface for a remote service. +* Ambassador provides logging, circuit breaking, retries and security on the client. + +## Typical Use Case + +* Control access to another object +* Implement logging +* Implement circuit breaking +* Offload remote service tasks +* Facilitate network connection + +### Known uses + +* [Kubernetes-native API gateway for microservices](https://github.com/datawire/ambassador) + +### Related patterns + +* [Proxy](https://java-design-patterns.com/patterns/proxy/) + +### Credits + +* [Ambassador pattern](https://docs.microsoft.com/en-us/azure/architecture/patterns/ambassador) +* [Designing Distributed Systems: Patterns and Paradigms for Scalable, Reliable Services](https://books.google.co.uk/books?id=6BJNDwAAQBAJ&pg=PT35&lpg=PT35&dq=ambassador+pattern+in+real+world&source=bl&ots=d2e7GhYdHi&sig=Lfl_MDnCgn6lUcjzOg4GXrN13bQ&hl=en&sa=X&ved=0ahUKEwjk9L_18rrbAhVpKcAKHX_KA7EQ6AEIWTAI#v=onepage&q=ambassador%20pattern%20in%20real%20world&f=false) + +## Api Gateway +[⬆](#content) + +--- +layout: pattern +title: API Gateway +folder: api-gateway +permalink: /patterns/api-gateway/ +categories: Architectural +tags: + - Cloud distributed + - Decoupling + - Microservices +--- + +### Intent + +Aggregate calls to microservices in a single location, the API Gateway. The user makes a single call +to the API Gateway, and the API Gateway then calls each relevant microservice. + +### Explanation + +With the Microservices pattern, a client may need data from multiple different microservices. If the +client called each microservice directly, that could contribute to longer load times, since the +client would have to make a network request for each microservice called. Moreover, having the +client call each microservice directly ties the client to that microservice - if the internal +implementations of the microservices change (for example, if two microservices are combined sometime +in the future) or if the location (host and port) of a microservice changes, then every client that +makes use of those microservices must be updated. + +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. + +Real world example + +> We are implementing microservices and API Gateway pattern for an e-commerce site. In this system +> the API Gateway makes calls to the Image and Price microservices. + +In plain words + +> For a system implemented using microservices architecture, API Gateway is the single entry point +> that aggregates the calls to the individual microservices. + +Wikipedia says + +> API Gateway is a server that acts as an API front-end, receives API requests, enforces throttling +> and security policies, passes requests to the back-end service and then passes the response back +> to the requester. A gateway often includes a transformation engine to orchestrate and modify the +> requests and responses on the fly. A gateway can also provide functionality such as collecting +> analytics data and providing caching. The gateway can provide functionality to support +> authentication, authorization, security, audit and regulatory compliance. + +**Programmatic Example** + +This implementation shows what the API Gateway pattern could look like for an e-commerce site. The +`ApiGateway` makes calls to the Image and Price microservices using the `ImageClientImpl` and +`PriceClientImpl` respectively. Customers viewing the site on a desktop device can see both price +information and an image of a product, so the `ApiGateway` calls both of the microservices and +aggregates the data in the `DesktopProduct` model. However, mobile users only see price information; +they do not see a product image. For mobile users, the `ApiGateway` only retrieves price +information, which it uses to populate the `MobileProduct`. + +Here's the Image microservice implementation. + +```java +public interface ImageClient { + String getImagePath(); +} + +public class ImageClientImpl implements ImageClient { + @Override + public String getImagePath() { + var httpClient = HttpClient.newHttpClient(); + var httpGet = HttpRequest.newBuilder() + .GET() + .uri(URI.create("http://localhost:50005/image-path")) + .build(); + + try { + var httpResponse = httpClient.send(httpGet, BodyHandlers.ofString()); + return httpResponse.body(); + } catch (IOException | InterruptedException e) { + e.printStackTrace(); + } + + return null; + } +} +``` + +Here's the Price microservice implementation. + +```java +public interface PriceClient { + String getPrice(); +} + +public class PriceClientImpl implements PriceClient { + + @Override + public String getPrice() { + var httpClient = HttpClient.newHttpClient(); + var httpGet = HttpRequest.newBuilder() + .GET() + .uri(URI.create("http://localhost:50006/price")) + .build(); + + try { + var httpResponse = httpClient.send(httpGet, BodyHandlers.ofString()); + return httpResponse.body(); + } catch (IOException | InterruptedException e) { + e.printStackTrace(); + } + + return null; + } +} +``` + +Here we can see how API Gateway maps the requests to the microservices. + +```java +public class ApiGateway { + + @Resource + private ImageClient imageClient; + + @Resource + private PriceClient priceClient; + + @RequestMapping(path = "/desktop", method = RequestMethod.GET) + public DesktopProduct getProductDesktop() { + var desktopProduct = new DesktopProduct(); + desktopProduct.setImagePath(imageClient.getImagePath()); + desktopProduct.setPrice(priceClient.getPrice()); + return desktopProduct; + } + + @RequestMapping(path = "/mobile", method = RequestMethod.GET) + public MobileProduct getProductMobile() { + var mobileProduct = new MobileProduct(); + mobileProduct.setPrice(priceClient.getPrice()); + return mobileProduct; + } +} +``` + +### Class diagram +![alt text](./etc/api-gateway.png "API Gateway") + +### Applicability + +Use the API Gateway pattern when + +* You're using microservices architecture and need a single point of aggregation for your microservice calls. + +### Credits + +* [microservices.io - API Gateway](http://microservices.io/patterns/apigateway.html) +* [NGINX - Building Microservices: Using an API Gateway](https://www.nginx.com/blog/building-microservices-using-an-api-gateway/) +* [Microservices Patterns: With examples in Java](https://www.amazon.com/gp/product/1617294543/ref=as_li_qf_asin_il_tl?ie=UTF8&tag=javadesignpat-20&creative=9325&linkCode=as2&creativeASIN=1617294543&linkId=ac7b6a57f866ac006a309d9086e8cfbd) +* [Building Microservices: Designing Fine-Grained Systems](https://www.amazon.com/gp/product/1491950358/ref=as_li_qf_asin_il_tl?ie=UTF8&tag=javadesignpat-20&creative=9325&linkCode=as2&creativeASIN=1491950358&linkId=4c95ca9831e05e3f0dadb08841d77bf1) + + +## Arrange/Act/Assert +[⬆](#content) + +--- +layout: pattern +title: Arrange/Act/Assert +folder: arrange-act-assert +permalink: /patterns/arrange-act-assert/ +categories: Idiom +tags: + - Testing +--- + +### Also known as + +Given/When/Then + +### Intent + +Arrange/Act/Assert (AAA) is a pattern for organizing unit tests. +It breaks tests down into three clear and distinct steps: + +1. Arrange: Perform the setup and initialization required for the test. +2. Act: Take action(s) required for the test. +3. Assert: Verify the outcome(s) of the test. + +### Explanation + +This pattern has several significant benefits. It creates a clear separation between a test's +setup, operations, and results. This structure makes the code easier to read and understand. If +you place the steps in order and format your code to separate them, you can scan a test and +quickly comprehend what it does. + +It also enforces a certain degree of discipline when you write your tests. You have to think +clearly about the three steps your test will perform. It makes tests more natural to write at +the same time since you already have an outline. + +Real world example + +> We need to write comprehensive and clear unit test suite for a class. + +In plain words + +> Arrange/Act/Assert is a testing pattern that organizes tests into three clear steps for easy +> maintenance. + +WikiWikiWeb says + +> Arrange/Act/Assert is a pattern for arranging and formatting code in UnitTest methods. + +**Programmatic Example** + +Let's first introduce our `Cash` class to be unit tested. + +```java +public class Cash { + + private int amount; + + Cash(int amount) { + this.amount = amount; + } + + void plus(int addend) { + amount += addend; + } + + boolean minus(int subtrahend) { + if (amount >= subtrahend) { + amount -= subtrahend; + return true; + } else { + return false; + } + } + + int count() { + return amount; + } +} +``` + +Then we write our unit tests according to Arrange/Act/Assert pattern. Notice the clearly +separated steps for each unit test. + +```java +public class CashAAATest { + + @Test + public void testPlus() { + //Arrange + var cash = new Cash(3); + //Act + cash.plus(4); + //Assert + assertEquals(7, cash.count()); + } + + @Test + public void testMinus() { + //Arrange + var cash = new Cash(8); + //Act + var result = cash.minus(5); + //Assert + assertTrue(result); + assertEquals(3, cash.count()); + } + + @Test + public void testInsufficientMinus() { + //Arrange + var cash = new Cash(1); + //Act + var result = cash.minus(6); + //Assert + assertFalse(result); + assertEquals(1, cash.count()); + } + + @Test + public void testUpdate() { + //Arrange + var cash = new Cash(5); + //Act + cash.plus(6); + var result = cash.minus(3); + //Assert + assertTrue(result); + assertEquals(8, cash.count()); + } +} +``` + +### Applicability + +Use Arrange/Act/Assert pattern when + +* You need to structure your unit tests so that they're easier to read, maintain, and enhance. + +### Credits + +* [Arrange, Act, Assert: What is AAA Testing?](https://blog.ncrunch.net/post/arrange-act-assert-aaa-testing.aspx) +* [Bill Wake: 3A – Arrange, Act, Assert](https://xp123.com/articles/3a-arrange-act-assert/) +* [Martin Fowler: GivenWhenThen](https://martinfowler.com/bliki/GivenWhenThen.html) +* [xUnit Test Patterns: Refactoring Test Code](https://www.amazon.com/gp/product/0131495054/ref=as_li_qf_asin_il_tl?ie=UTF8&tag=javadesignpat-20&creative=9325&linkCode=as2&creativeASIN=0131495054&linkId=99701e8f4af2f7e8dd50d720c9b63dbf) +* [Unit Testing Principles, Practices, and Patterns](https://www.amazon.com/gp/product/1617296279/ref=as_li_qf_asin_il_tl?ie=UTF8&tag=javadesignpat-20&creative=9325&linkCode=as2&creativeASIN=1617296279&linkId=74c75cf22a63c3e4758ae08aa0a0cc35) +* [Test Driven Development: By Example](https://www.amazon.com/gp/product/0321146530/ref=as_li_qf_asin_il_tl?ie=UTF8&tag=javadesignpat-20&creative=9325&linkCode=as2&creativeASIN=0321146530&linkId=5c63a93d8c1175b84ca5087472ef0e05) + + +## Async Method Invocation +[⬆](#content) + +--- +layout: pattern +title: Async Method Invocation +folder: async-method-invocation +permalink: /patterns/async-method-invocation/ +categories: Concurrency +tags: + - Reactive +--- + +### Intent +Asynchronous method invocation is pattern where the calling thread +is not blocked while waiting results of tasks. The pattern provides parallel +processing of multiple independent tasks and retrieving the results via +callbacks or waiting until everything is done. + +# Class diagram +![alt text](./etc/async-method-invocation.png "Async Method Invocation") + +### Applicability +Use async method invocation pattern when + +* you have multiple independent tasks that can run in parallel +* you need to improve the performance of a group of sequential tasks +* you have limited amount of processing capacity or long running tasks and the + caller should not wait the tasks to be ready + +## Real world examples + +* [FutureTask](http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/FutureTask.html), [CompletableFuture](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/CompletableFuture.html) and [ExecutorService](http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ExecutorService.html) (Java) +* [Task-based Asynchronous Pattern](https://msdn.microsoft.com/en-us/library/hh873175.aspx) (.NET) + +## Balking +[⬆](#content) + +--- +layout: pattern +title: Balking +folder: balking +permalink: /patterns/balking/ +categories: Concurrency +tags: + - Decoupling +--- + +### Intent +Balking Pattern is used to prevent an object from executing certain code if it is an +incomplete or inappropriate state + +### Class diagram +![alt text](./etc/balking.png "Balking") + +### Applicability +Use the Balking pattern when + +* you want to invoke an action on an object only when it is in a particular state +* objects are generally only in a state that is prone to balking temporarily +but for an unknown amount of time + +### Related patterns +* Guarded Suspension Pattern +* Double Checked Locking Pattern + +## Bridge +[⬆](#content) + +--- +layout: pattern +title: Bridge +folder: bridge +permalink: /patterns/bridge/ +categories: Structural +tags: + - Gang of Four +--- + +### Also known as + +Handle/Body + +### Intent + +Decouple an abstraction from its implementation so that the two can vary independently. + +### Explanation + +Real world example + +> Consider you have a weapon with different enchantments, and you are supposed to allow mixing +> different weapons with different enchantments. What would you do? Create multiple copies of each +> of the weapons for each of the enchantments or would you just create separate enchantment and set +> it for the weapon as needed? Bridge pattern allows you to do the second. + +In Plain Words + +> Bridge pattern is about preferring composition over inheritance. Implementation details are pushed +> from a hierarchy to another object with a separate hierarchy. + +Wikipedia says + +> The bridge pattern is a design pattern used in software engineering that is meant to "decouple an abstraction from its implementation so that the two can vary independently" + +**Programmatic Example** + +Translating our weapon example from above. Here we have the `Weapon` hierarchy: + +```java +public interface Weapon { + void wield(); + void swing(); + void unwield(); + Enchantment getEnchantment(); +} + +public class Sword implements Weapon { + + private final Enchantment enchantment; + + public Sword(Enchantment enchantment) { + this.enchantment = enchantment; + } + + @Override + public void wield() { + LOGGER.info("The sword is wielded."); + enchantment.onActivate(); + } + + @Override + public void swing() { + LOGGER.info("The sword is swinged."); + enchantment.apply(); + } + + @Override + public void unwield() { + LOGGER.info("The sword is unwielded."); + enchantment.onDeactivate(); + } + + @Override + public Enchantment getEnchantment() { + return enchantment; + } +} + +public class Hammer implements Weapon { + + private final Enchantment enchantment; + + public Hammer(Enchantment enchantment) { + this.enchantment = enchantment; + } + + @Override + public void wield() { + LOGGER.info("The hammer is wielded."); + enchantment.onActivate(); + } + + @Override + public void swing() { + LOGGER.info("The hammer is swinged."); + enchantment.apply(); + } + + @Override + public void unwield() { + LOGGER.info("The hammer is unwielded."); + enchantment.onDeactivate(); + } + + @Override + public Enchantment getEnchantment() { + return enchantment; + } +} +``` + +Here's the separate enchantment hierarchy: + +```java +public interface Enchantment { + void onActivate(); + void apply(); + void onDeactivate(); +} + +public class FlyingEnchantment implements Enchantment { + + @Override + public void onActivate() { + LOGGER.info("The item begins to glow faintly."); + } + + @Override + public void apply() { + LOGGER.info("The item flies and strikes the enemies finally returning to owner's hand."); + } + + @Override + public void onDeactivate() { + LOGGER.info("The item's glow fades."); + } +} + +public class SoulEatingEnchantment implements Enchantment { + + @Override + public void onActivate() { + LOGGER.info("The item spreads bloodlust."); + } + + @Override + public void apply() { + LOGGER.info("The item eats the soul of enemies."); + } + + @Override + public void onDeactivate() { + LOGGER.info("Bloodlust slowly disappears."); + } +} +``` + +Here are both hierarchies in action: + +```java +var enchantedSword = new Sword(new SoulEatingEnchantment()); +enchantedSword.wield(); +enchantedSword.swing(); +enchantedSword.unwield(); +// The sword is wielded. +// The item spreads bloodlust. +// The sword is swinged. +// The item eats the soul of enemies. +// The sword is unwielded. +// Bloodlust slowly disappears. + +var hammer = new Hammer(new FlyingEnchantment()); +hammer.wield(); +hammer.swing(); +hammer.unwield(); +// The hammer is wielded. +// The item begins to glow faintly. +// The hammer is swinged. +// The item flies and strikes the enemies finally returning to owner's hand. +// The hammer is unwielded. +// The item's glow fades. +``` + +### Class Diagram + +![alt text](./etc/bridge.urm.png "Bridge class diagram") + +### Applicability + +Use the Bridge pattern when + +* You want to avoid a permanent binding between an abstraction and its implementation. This might be the case, for example, when the implementation must be selected or switched at run-time. +* Both the abstractions and their implementations should be extensible by subclassing. In this case, the Bridge pattern lets you combine the different abstractions and implementations and extend them independently. +* Changes in the implementation of an abstraction should have no impact on clients; that is, their code should not have to be recompiled. +* You have a proliferation of classes. Such a class hierarchy indicates the need for splitting an object into two parts. Rumbaugh uses the term "nested generalizations" to refer to such class hierarchies. +* You want to share an implementation among multiple objects (perhaps using reference counting), and this fact should be hidden from the client. A simple example is Coplien's String class, in which multiple objects can share the same string representation. + +### Tutorial + +* [Bridge Pattern Tutorial](https://www.journaldev.com/1491/bridge-design-pattern-java) + +### Credits + +* [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/gp/product/0201633612/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0201633612&linkCode=as2&tag=javadesignpat-20&linkId=675d49790ce11db99d90bde47f1aeb59) +* [Head First Design Patterns: A Brain-Friendly Guide](https://www.amazon.com/gp/product/0596007124/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596007124&linkCode=as2&tag=javadesignpat-20&linkId=6b8b6eea86021af6c8e3cd3fc382cb5b) + + +## Builder +[⬆](#content) + +--- +layout: pattern +title: Builder +folder: builder +permalink: /patterns/builder/ +categories: Creational +tags: + - Gang of Four +--- + +### Intent + +Separate the construction of a complex object from its representation so that the same construction +process can create different representations. + +### Explanation + +Real world example + +> Imagine a character generator for a role-playing game. The easiest option is to let the computer +> create the character for you. If you want to manually select the character details like +> profession, gender, hair color etc. the character generation becomes a step-by-step process that +> completes when all the selections are ready. + +In plain words + +> Allows you to create different flavors of an object while avoiding constructor pollution. Useful +> when there could be several flavors of an object. Or when there are a lot of steps involved in +> creation of an object. + +Wikipedia says + +> The builder pattern is an object creation software design pattern with the intentions of finding +> a solution to the telescoping constructor anti-pattern. + +Having said that let me add a bit about what telescoping constructor anti-pattern is. At one point +or the other, we have all seen a constructor like below: + +```java +public Hero(Profession profession, String name, HairType hairType, HairColor hairColor, Armor armor, Weapon weapon) { +} +``` + +As you can see the number of constructor parameters can quickly get out of hand, and it may become +difficult to understand the arrangement of parameters. Plus this parameter list could keep on +growing if you would want to add more options in the future. This is called telescoping constructor +anti-pattern. + +**Programmatic Example** + +The sane alternative is to use the Builder pattern. First of all we have our hero that we want to +create: + +```java +public final class Hero { + private final Profession profession; + private final String name; + private final HairType hairType; + private final HairColor hairColor; + private final Armor armor; + private final Weapon weapon; + + private Hero(Builder builder) { + this.profession = builder.profession; + this.name = builder.name; + this.hairColor = builder.hairColor; + this.hairType = builder.hairType; + this.weapon = builder.weapon; + this.armor = builder.armor; + } +} +``` + +Then we have the builder: + +```java + public static class Builder { + private final Profession profession; + private final String name; + private HairType hairType; + private HairColor hairColor; + private Armor armor; + private Weapon weapon; + + public Builder(Profession profession, String name) { + if (profession == null || name == null) { + throw new IllegalArgumentException("profession and name can not be null"); + } + this.profession = profession; + this.name = name; + } + + public Builder withHairType(HairType hairType) { + this.hairType = hairType; + return this; + } + + public Builder withHairColor(HairColor hairColor) { + this.hairColor = hairColor; + return this; + } + + public Builder withArmor(Armor armor) { + this.armor = armor; + return this; + } + + public Builder withWeapon(Weapon weapon) { + this.weapon = weapon; + return this; + } + + public Hero build() { + return new Hero(this); + } + } +``` + +Then it can be used as: + +```java +var mage = new Hero.Builder(Profession.MAGE, "Riobard").withHairColor(HairColor.BLACK).withWeapon(Weapon.DAGGER).build(); +``` + +### Class diagram + +![alt text](./etc/builder.urm.png "Builder class diagram") + +### Applicability + +Use the Builder pattern when + +* The algorithm for creating a complex object should be independent of the parts that make up the object and how they're assembled +* The construction process must allow different representations for the object that's constructed + +## Real world examples + +* [java.lang.StringBuilder](http://docs.oracle.com/javase/8/docs/api/java/lang/StringBuilder.html) +* [java.nio.ByteBuffer](http://docs.oracle.com/javase/8/docs/api/java/nio/ByteBuffer.html#put-byte-) as well as similar buffers such as FloatBuffer, IntBuffer and so on. +* [java.lang.StringBuffer](http://docs.oracle.com/javase/8/docs/api/java/lang/StringBuffer.html#append-boolean-) +* All implementations of [java.lang.Appendable](http://docs.oracle.com/javase/8/docs/api/java/lang/Appendable.html) +* [Apache Camel builders](https://github.com/apache/camel/tree/0e195428ee04531be27a0b659005e3aa8d159d23/camel-core/src/main/java/org/apache/camel/builder) +* [Apache Commons Option.Builder](https://commons.apache.org/proper/commons-cli/apidocs/org/apache/commons/cli/Option.Builder.html) + +### Credits + +* [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/gp/product/0201633612/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0201633612&linkCode=as2&tag=javadesignpat-20&linkId=675d49790ce11db99d90bde47f1aeb59) +* [Effective Java](https://www.amazon.com/gp/product/0134685997/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0134685997&linkCode=as2&tag=javadesignpat-20&linkId=4e349f4b3ff8c50123f8147c828e53eb) +* [Head First Design Patterns: A Brain-Friendly Guide](https://www.amazon.com/gp/product/0596007124/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596007124&linkCode=as2&tag=javadesignpat-20&linkId=6b8b6eea86021af6c8e3cd3fc382cb5b) +* [Refactoring to Patterns](https://www.amazon.com/gp/product/0321213351/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0321213351&linkCode=as2&tag=javadesignpat-20&linkId=2a76fcb387234bc71b1c61150b3cc3a7) + + +## Business Delegate +[⬆](#content) + +--- +layout: pattern +title: Business Delegate +folder: business-delegate +permalink: /patterns/business-delegate/ +categories: Structural +tags: + - Decoupling +--- + +### Intent +The Business Delegate pattern adds an abstraction layer between +presentation and business tiers. By using the pattern we gain loose coupling +between the tiers and encapsulate knowledge about how to locate, connect to, +and interact with the business objects that make up the application. + +### Class diagram +![alt text](./etc/business-delegate.png "Business Delegate") + +### Applicability +Use the Business Delegate pattern when + +* you want loose coupling between presentation and business tiers +* you want to orchestrate calls to multiple business services +* you want to encapsulate service lookups and service calls + +### Credits + +* [J2EE Design Patterns](https://www.amazon.com/gp/product/0596004273/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596004273&linkCode=as2&tag=javadesignpat-20&linkId=48d37c67fb3d845b802fa9b619ad8f31) + + +## Bytecode +[⬆](#content) + +--- +layout: pattern +title: Bytecode +folder: bytecode +permalink: /patterns/bytecode/ +categories: Behavioral +tags: + - Game programming +--- + +### Intent +Allows to encode behaviour as instructions for virtual machine. + +### Class diagram +![alt text](./etc/bytecode.urm.png "Bytecode class diagram") + +### Applicability +Use the Bytecode pattern when you have a lot of behavior you need to define and your +game’s implementation language isn’t a good fit because: + +* it’s too low-level, making it tedious or error-prone to program in. +* iterating on it takes too long due to slow compile times or other tooling issues. +* it has too much trust. If you want to ensure the behavior being defined can’t break the game, you need to sandbox it from the rest of the codebase. + +### Credits + +* [Game programming patterns](http://gameprogrammingpatterns.com/bytecode.html) + +## Caching +[⬆](#content) + +--- +layout: pattern +title: Caching +folder: caching +permalink: /patterns/caching/ +categories: Behavioral +tags: + - Performance + - Cloud distributed +--- + +### Intent +To avoid expensive re-acquisition of resources by not releasing +the resources immediately after their use. The resources retain their identity, are kept in some +fast-access storage, and are re-used to avoid having to acquire them again. + +### Class diagram +![alt text](./etc/caching.png "Caching") + +### Applicability +Use the Caching pattern(s) when + +* Repetitious acquisition, initialization, and release of the same resource causes unnecessary performance overhead. + +### Credits + +* [Write-through, write-around, write-back: Cache explained](http://www.computerweekly.com/feature/Write-through-write-around-write-back-Cache-explained) +* [Read-Through, Write-Through, Write-Behind, and Refresh-Ahead Caching](https://docs.oracle.com/cd/E15357_01/coh.360/e15723/cache_rtwtwbra.htm#COHDG5177) +* [Cache-Aside pattern](https://docs.microsoft.com/en-us/azure/architecture/patterns/cache-aside) + + +## Callback +[⬆](#content) + +--- +layout: pattern +title: Callback +folder: callback +permalink: /patterns/callback/ +categories: Idiom +tags: + - Reactive +--- + +### Intent + +Callback is a piece of executable code that is passed as an argument to other code, which is +expected to call back (execute) the argument at some convenient time. + +### Explanation + +Real world example + +> We need to be notified after executing task has finished. We pass a callback method for +> the executor and wait for it to call back on us. + +In plain words + +> Callback is a method passed to the executor which will be called at defined moment. + +Wikipedia says + +> In computer programming, a callback, also known as a "call-after" function, is any executable +> code that is passed as an argument to other code; that other code is expected to call +> back (execute) the argument at a given time. + +**Programmatic Example** + +Callback is a simple interface with single method. + +```java +public interface Callback { + + void call(); +} +``` + +Next we define a task that will execute the callback after the task execution has finished. + +```java +public abstract class Task { + + final void executeWith(Callback callback) { + execute(); + Optional.ofNullable(callback).ifPresent(Callback::call); + } + + public abstract void execute(); +} + +public final class SimpleTask extends Task { + + private static final Logger LOGGER = getLogger(SimpleTask.class); + + @Override + public void execute() { + LOGGER.info("Perform some important activity and after call the callback method."); + } +} +``` + +Finally, here's how we execute a task and receive a callback when it's finished. + +```java + var task = new SimpleTask(); + task.executeWith(() -> LOGGER.info("I'm done now.")); +``` + +### Class diagram + +![alt text](./etc/callback.png "Callback") + +### Applicability + +Use the Callback pattern when + +* when some arbitrary synchronous or asynchronous action must be performed after execution of some defined activity. + +## Real world examples + +* [CyclicBarrier](http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/CyclicBarrier.html#CyclicBarrier%28int,%20java.lang.Runnable%29) constructor can accept a callback that will be triggered every time a barrier is tripped. + + +## Chain of Responsibility +[⬆](#content) + +--- +layout: pattern +title: Chain of responsibility +folder: chain +permalink: /patterns/chain/ +categories: Behavioral +tags: + - Gang of Four +--- + +### Intent +Avoid coupling the sender of a request to its receiver by giving more than one object a chance to +handle the request. Chain the receiving objects and pass the request along the chain until an object +handles it. + +### Explanation + +Real world example + +> The Orc King gives loud orders to his army. The closest one to react is the commander, then +> officer and then soldier. The commander, officer and soldier here form a chain of responsibility. + +In plain words + +> It helps to build a chain of objects. A request enters from one end and keeps going from an object +> to another until it finds a suitable handler. + +Wikipedia says + +> In object-oriented design, the chain-of-responsibility pattern is a design pattern consisting of +> a source of command objects and a series of processing objects. Each processing object contains +> logic that defines the types of command objects that it can handle; the rest are passed to the +> next processing object in the chain. + +**Programmatic Example** + +Translating our example with the orcs from above. First we have the `Request` class: + +```java +public class Request { + + private final RequestType requestType; + private final String requestDescription; + private boolean handled; + + public Request(final RequestType requestType, final String requestDescription) { + this.requestType = Objects.requireNonNull(requestType); + this.requestDescription = Objects.requireNonNull(requestDescription); + } + + public String getRequestDescription() { return requestDescription; } + + public RequestType getRequestType() { return requestType; } + + public void markHandled() { this.handled = true; } + + public boolean isHandled() { return this.handled; } + + @Override + public String toString() { return getRequestDescription(); } +} + +public enum RequestType { + DEFEND_CASTLE, TORTURE_PRISONER, COLLECT_TAX +} +``` + +Then the request handler hierarchy + +```java +public abstract class RequestHandler { + private static final Logger LOGGER = LoggerFactory.getLogger(RequestHandler.class); + private final RequestHandler next; + + public RequestHandler(RequestHandler next) { + this.next = next; + } + + public void handleRequest(Request req) { + if (next != null) { + next.handleRequest(req); + } + } + + protected void printHandling(Request req) { + LOGGER.info("{} handling request \"{}\"", this, req); + } + + @Override + public abstract String toString(); +} + +public class OrcCommander extends RequestHandler { + public OrcCommander(RequestHandler handler) { + super(handler); + } + + @Override + public void handleRequest(Request req) { + if (req.getRequestType().equals(RequestType.DEFEND_CASTLE)) { + printHandling(req); + req.markHandled(); + } else { + super.handleRequest(req); + } + } + + @Override + public String toString() { + return "Orc commander"; + } +} + +// OrcOfficer and OrcSoldier are defined similarly as OrcCommander + +``` + +Then we have the Orc King who gives the orders and forms the chain + +```java +public class OrcKing { + RequestHandler chain; + + public OrcKing() { + buildChain(); + } + + private void buildChain() { + chain = new OrcCommander(new OrcOfficer(new OrcSoldier(null))); + } + + public void makeRequest(Request req) { + chain.handleRequest(req); + } +} +``` + +Then it is used as follows + +```java +var king = new OrcKing(); +king.makeRequest(new Request(RequestType.DEFEND_CASTLE, "defend castle")); // Orc commander handling request "defend castle" +king.makeRequest(new Request(RequestType.TORTURE_PRISONER, "torture prisoner")); // Orc officer handling request "torture prisoner" +king.makeRequest(new Request(RequestType.COLLECT_TAX, "collect tax")); // Orc soldier handling request "collect tax" +``` + +### Class diagram + +![alt text](./etc/chain.urm.png "Chain of Responsibility class diagram") + +### Applicability + +Use Chain of Responsibility when + +* More than one object may handle a request, and the handler isn't known a priori. The handler should be ascertained automatically. +* You want to issue a request to one of several objects without specifying the receiver explicitly. +* The set of objects that can handle a request should be specified dynamically. + +## Real world examples + +* [java.util.logging.Logger#log()](http://docs.oracle.com/javase/8/docs/api/java/util/logging/Logger.html#log%28java.util.logging.Level,%20java.lang.String%29) +* [Apache Commons Chain](https://commons.apache.org/proper/commons-chain/index.html) +* [javax.servlet.Filter#doFilter()](http://docs.oracle.com/javaee/7/api/javax/servlet/Filter.html#doFilter-javax.servlet.ServletRequest-javax.servlet.ServletResponse-javax.servlet.FilterChain-) + +### Credits + +* [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/gp/product/0201633612/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0201633612&linkCode=as2&tag=javadesignpat-20&linkId=675d49790ce11db99d90bde47f1aeb59) +* [Head First Design Patterns: A Brain-Friendly Guide](https://www.amazon.com/gp/product/0596007124/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596007124&linkCode=as2&tag=javadesignpat-20&linkId=6b8b6eea86021af6c8e3cd3fc382cb5b) + + +## Circuit Breaker +[⬆](#content) + +--- +layout: pattern +title: Circuit Breaker +folder: circuit-breaker +permalink: /patterns/circuit-breaker/ +categories: Behavioral +tags: + - Performance + - Decoupling + - Cloud distributed +--- + +### Intent + +Handle costly remote service calls in such a way that the failure of a single service/component +cannot bring the whole application down, and we can reconnect to the service as soon as possible. + +### Explanation + +Real world example + +> Imagine a web application that has both local files/images and remote services that are used for +> fetching data. These remote services may be either healthy and responsive at times, or may become +> slow and unresponsive at some point of time due to variety of reasons. So if one of the remote +> services is slow or not responding successfully, our application will try to fetch response from +> the remote service using multiple threads/processes, soon all of them will hang (also called +> [thread starvation](https://en.wikipedia.org/wiki/Starvation_(computer_science))) causing our entire web application to crash. We should be able to detect +> this situation and show the user an appropriate message so that he/she can explore other parts of +> the app unaffected by the remote service failure. Meanwhile, the other services that are working +> normally, should keep functioning unaffected by this failure. + +In plain words + +> Circuit Breaker allows graceful handling of failed remote services. It's especially useful when +> all parts of our application are highly decoupled from each other, and failure of one component +> doesn't mean the other parts will stop working. + +Wikipedia says + +> Circuit breaker is a design pattern used in modern software development. It is used to detect +> failures and encapsulates the logic of preventing a failure from constantly recurring, during +> maintenance, temporary external system failure or unexpected system difficulties. + +## Programmatic Example + +So, how does this all come together? With the above example in mind we will imitate the +functionality in a simple example. A monitoring service mimics the web app and makes both local and +remote calls. + +The service architecture is as follows: + +![alt text](./etc/ServiceDiagram.PNG "Service Diagram") + +In terms of code, the end user application is: + +```java +public class App { + + private static final Logger LOGGER = LoggerFactory.getLogger(App.class); + + /** + * Program entry point. + * + * @param args command line args + */ + public static void main(String[] args) { + + var serverStartTime = System.nanoTime(); + + var delayedService = new DelayedRemoteService(serverStartTime, 5); + var delayedServiceCircuitBreaker = new DefaultCircuitBreaker(delayedService, 3000, 2, + 2000 * 1000 * 1000); + + var quickService = new QuickRemoteService(); + var quickServiceCircuitBreaker = new DefaultCircuitBreaker(quickService, 3000, 2, + 2000 * 1000 * 1000); + + //Create an object of monitoring service which makes both local and remote calls + var monitoringService = new MonitoringService(delayedServiceCircuitBreaker, + quickServiceCircuitBreaker); + + //Fetch response from local resource + LOGGER.info(monitoringService.localResourceResponse()); + + //Fetch response from delayed service 2 times, to meet the failure threshold + LOGGER.info(monitoringService.delayedServiceResponse()); + LOGGER.info(monitoringService.delayedServiceResponse()); + + //Fetch current state of delayed service circuit breaker after crossing failure threshold limit + //which is OPEN now + LOGGER.info(delayedServiceCircuitBreaker.getState()); + + //Meanwhile, the delayed service is down, fetch response from the healthy quick service + LOGGER.info(monitoringService.quickServiceResponse()); + LOGGER.info(quickServiceCircuitBreaker.getState()); + + //Wait for the delayed service to become responsive + try { + LOGGER.info("Waiting for delayed service to become responsive"); + Thread.sleep(5000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + //Check the state of delayed circuit breaker, should be HALF_OPEN + LOGGER.info(delayedServiceCircuitBreaker.getState()); + + //Fetch response from delayed service, which should be healthy by now + LOGGER.info(monitoringService.delayedServiceResponse()); + //As successful response is fetched, it should be CLOSED again. + LOGGER.info(delayedServiceCircuitBreaker.getState()); + } +} +``` + +The monitoring service: + +```java +public class MonitoringService { + + private final CircuitBreaker delayedService; + + private final CircuitBreaker quickService; + + public MonitoringService(CircuitBreaker delayedService, CircuitBreaker quickService) { + this.delayedService = delayedService; + this.quickService = quickService; + } + + //Assumption: Local service won't fail, no need to wrap it in a circuit breaker logic + public String localResourceResponse() { + return "Local Service is working"; + } + + /** + * Fetch response from the delayed service (with some simulated startup time). + * + * @return response string + */ + public String delayedServiceResponse() { + try { + return this.delayedService.attemptRequest(); + } catch (RemoteServiceException e) { + return e.getMessage(); + } + } + + /** + * Fetches response from a healthy service without any failure. + * + * @return response string + */ + public String quickServiceResponse() { + try { + return this.quickService.attemptRequest(); + } catch (RemoteServiceException e) { + return e.getMessage(); + } + } +} +``` +As it can be seen, it does the call to get local resources directly, but it wraps the call to +remote (costly) service in a circuit breaker object, which prevents faults as follows: + +```java +public class DefaultCircuitBreaker implements CircuitBreaker { + + private final long timeout; + private final long retryTimePeriod; + private final RemoteService service; + long lastFailureTime; + private String lastFailureResponse; + int failureCount; + private final int failureThreshold; + private State state; + private final long futureTime = 1000 * 1000 * 1000 * 1000; + + /** + * Constructor to create an instance of Circuit Breaker. + * + * @param timeout Timeout for the API request. Not necessary for this simple example + * @param failureThreshold Number of failures we receive from the depended service before changing + * state to 'OPEN' + * @param retryTimePeriod Time period after which a new request is made to remote service for + * status check. + */ + DefaultCircuitBreaker(RemoteService serviceToCall, long timeout, int failureThreshold, + long retryTimePeriod) { + this.service = serviceToCall; + // We start in a closed state hoping that everything is fine + this.state = State.CLOSED; + this.failureThreshold = failureThreshold; + // Timeout for the API request. + // Used to break the calls made to remote resource if it exceeds the limit + this.timeout = timeout; + this.retryTimePeriod = retryTimePeriod; + //An absurd amount of time in future which basically indicates the last failure never happened + this.lastFailureTime = System.nanoTime() + futureTime; + this.failureCount = 0; + } + + // Reset everything to defaults + @Override + public void recordSuccess() { + this.failureCount = 0; + this.lastFailureTime = System.nanoTime() + futureTime; + this.state = State.CLOSED; + } + + @Override + public void recordFailure(String response) { + failureCount = failureCount + 1; + this.lastFailureTime = System.nanoTime(); + // Cache the failure response for returning on open state + this.lastFailureResponse = response; + } + + // Evaluate the current state based on failureThreshold, failureCount and lastFailureTime. + protected void evaluateState() { + if (failureCount >= failureThreshold) { //Then something is wrong with remote service + if ((System.nanoTime() - lastFailureTime) > retryTimePeriod) { + //We have waited long enough and should try checking if service is up + state = State.HALF_OPEN; + } else { + //Service would still probably be down + state = State.OPEN; + } + } else { + //Everything is working fine + state = State.CLOSED; + } + } + + @Override + public String getState() { + evaluateState(); + return state.name(); + } + + /** + * Break the circuit beforehand if it is known service is down Or connect the circuit manually if + * service comes online before expected. + * + * @param state State at which circuit is in + */ + @Override + public void setState(State state) { + this.state = state; + switch (state) { + case OPEN: + this.failureCount = failureThreshold; + this.lastFailureTime = System.nanoTime(); + break; + case HALF_OPEN: + this.failureCount = failureThreshold; + this.lastFailureTime = System.nanoTime() - retryTimePeriod; + break; + default: + this.failureCount = 0; + } + } + + /** + * Executes service call. + * + * @return Value from the remote resource, stale response or a custom exception + */ + @Override + public String attemptRequest() throws RemoteServiceException { + evaluateState(); + if (state == State.OPEN) { + // return cached response if the circuit is in OPEN state + return this.lastFailureResponse; + } else { + // Make the API request if the circuit is not OPEN + try { + //In a real application, this would be run in a thread and the timeout + //parameter of the circuit breaker would be utilized to know if service + //is working. Here, we simulate that based on server response itself + var response = service.call(); + // Yay!! the API responded fine. Let's reset everything. + recordSuccess(); + return response; + } catch (RemoteServiceException ex) { + recordFailure(ex.getMessage()); + throw ex; + } + } + } +} +``` + +How does the above pattern prevent failures? Let's understand via this finite state machine +implemented by it. + +![alt text](./etc/StateDiagram.PNG "State Diagram") + +- We initialize the Circuit Breaker object with certain parameters: `timeout`, `failureThreshold` and `retryTimePeriod` which help determine how resilient the API is. +- Initially, we are in the `closed` state and nos remote calls to the API have occurred. +- Every time the call succeeds, we reset the state to as it was in the beginning. +- If the number of failures cross a certain threshold, we move to the `open` state, which acts just like an open circuit and prevents remote service calls from being made, thus saving resources. (Here, we return the response called ```stale response from API```) +- Once we exceed the retry timeout period, we move to the `half-open` state and make another call to the remote service again to check if the service is working so that we can serve fresh content. A failure sets it back to `open` state and another attempt is made after retry timeout period, while a success sets it to `closed` state so that everything starts working normally again. + +### Class diagram + +![alt text](./etc/circuit-breaker.urm.png "Circuit Breaker class diagram") + +### Applicability + +Use the Circuit Breaker pattern when + +- Building a fault-tolerant application where failure of some services shouldn't bring the entire application down. +- Building a continuously running (always-on) application, so that its components can be upgraded without shutting it down entirely. + +## Related Patterns + +- [Retry Pattern](https://github.com/iluwatar/java-design-patterns/tree/master/retry) + +## Real world examples + +* [Spring Circuit Breaker module](https://spring.io/guides/gs/circuit-breaker) +* [Netflix Hystrix API](https://github.com/Netflix/Hystrix) + +### Credits + +* [Understanding Circuit Breaker Pattern](https://itnext.io/understand-circuitbreaker-design-pattern-with-simple-practical-example-92a752615b42) +* [Martin Fowler on Circuit Breaker](https://martinfowler.com/bliki/CircuitBreaker.html) +* [Fault tolerance in a high volume, distributed system](https://medium.com/netflix-techblog/fault-tolerance-in-a-high-volume-distributed-system-91ab4faae74a) +* [Circuit Breaker pattern](https://docs.microsoft.com/en-us/azure/architecture/patterns/circuit-breaker) + +## Collection Pipelline +[⬆](#content) + +--- +layout: pattern +title: Collection Pipeline +folder: collection-pipeline +permalink: /patterns/collection-pipeline/ +categories: Functional +tags: + - Reactive +--- + +### Intent +Collection Pipeline introduces Function Composition and Collection Pipeline, two functional-style patterns that you can combine to iterate collections in your code. +In functional programming, it's common to sequence complex operations through a series of smaller modular functions or operations. The series is called a composition of functions, or a function composition. When a collection of data flows through a function composition, it becomes a collection pipeline. Function Composition and Collection Pipeline are two design patterns frequently used in functional-style programming. + +### Class diagram +![alt text](./etc/collection-pipeline.png "Collection Pipeline") + +### Applicability +Use the Collection Pipeline pattern when + +* When you want to perform a sequence of operations where one operation's collected output is fed into the next +* When you use a lot of statements in your code +* When you use a lot of loops in your code + +### Credits + +* [Function composition and the Collection Pipeline pattern](https://www.ibm.com/developerworks/library/j-java8idioms2/index.html) +* [Martin Fowler](https://martinfowler.com/articles/collection-pipeline/) +* [Java8 Streams](https://docs.oracle.com/javase/8/docs/api/java/util/stream/package-summary.html) + + +## Combinator +[⬆](#content) + +--- +layout: pattern +title: Combinator +folder: combinator +permalink: /patterns/combinator/ +categories: Idiom +tags: + - Reactive +--- + +### Also known as +Composition pattern + +### Intent +The functional pattern representing a style of organizing libraries centered around the idea of combining functions. +Putting it simply, there is some type T, some functions for constructing "primitive" values of type T, +and some "combinators" which can combine values of type T in various ways to build up more complex values of type T. + +### Class diagram +![alt text](./etc/combinator.urm.png "Combinator class diagram") + +### Applicability +Use the combinator pattern when: + +- You are able to create a more complex value from more plain values but having the same type(a combination of them) + +## Real world examples + +- java.util.function.Function#compose +- java.util.function.Function#andThen + +### Credits + +- [Example for java](https://gtrefs.github.io/code/combinator-pattern/) +- [Combinator pattern](https://wiki.haskell.org/Combinator_pattern) +- [Combinatory logic](https://wiki.haskell.org/Combinatory_logic) + +## Command +[⬆](#content) + +--- +layout: pattern +title: Command +folder: command +permalink: /patterns/command/ +categories: Behavioral +tags: + - Gang of Four +--- + +### Also known as + +Action, Transaction + +### Intent + +Encapsulate a request as an object, thereby letting you parameterize clients with different +requests, queue or log requests, and support undoable operations. + +### Explanation +Real world example + +> There is a wizard casting spells on a goblin. The spells are executed on the goblin one by one. +> The first spell shrinks the goblin and the second makes him invisible. Then the wizard reverses +> the spells one by one. Each spell here is a command object that can be undone. + +In plain words + +> Storing requests as command objects allows performing an action or undoing it at a later time. + +Wikipedia says + +> In object-oriented programming, the command pattern is a behavioral design pattern in which an +> object is used to encapsulate all information needed to perform an action or trigger an event at +> a later time. + +**Programmatic Example** + +Here's the sample code with wizard and goblin. Let's start from the `Wizard` class. + +```java +public class Wizard { + + private final Deque undoStack = new LinkedList<>(); + private final Deque redoStack = new LinkedList<>(); + + public Wizard() {} + + public void castSpell(Runnable runnable) { + runnable.run(); + undoStack.offerLast(runnable); + } + + public void undoLastSpell() { + if (!undoStack.isEmpty()) { + var previousSpell = undoStack.pollLast(); + redoStack.offerLast(previousSpell); + previousSpell.run(); + } + } + + public void redoLastSpell() { + if (!redoStack.isEmpty()) { + var previousSpell = redoStack.pollLast(); + undoStack.offerLast(previousSpell); + previousSpell.run(); + } + } + + @Override + public String toString() { + return "Wizard"; + } +} +``` + +Next, we have the goblin who's the target of the spells. + +```java +public abstract class Target { + + private static final Logger LOGGER = LoggerFactory.getLogger(Target.class); + + private Size size; + + private Visibility visibility; + + public Size getSize() { + return size; + } + + public void setSize(Size size) { + this.size = size; + } + + public Visibility getVisibility() { + return visibility; + } + + public void setVisibility(Visibility visibility) { + this.visibility = visibility; + } + + @Override + public abstract String toString(); + + public void printStatus() { + LOGGER.info("{}, [size={}] [visibility={}]", this, getSize(), getVisibility()); + } +} + +public class Goblin extends Target { + + public Goblin() { + setSize(Size.NORMAL); + setVisibility(Visibility.VISIBLE); + } + + @Override + public String toString() { + return "Goblin"; + } + + public void changeSize() { + var oldSize = getSize() == Size.NORMAL ? Size.SMALL : Size.NORMAL; + setSize(oldSize); + } + + public void changeVisibility() { + var visible = getVisibility() == Visibility.INVISIBLE + ? Visibility.VISIBLE : Visibility.INVISIBLE; + setVisibility(visible); + } +} +``` + +Finally we have the wizard in main function who casts spell + +```java +public static void main(String[] args) { + var wizard = new Wizard(); + var goblin = new Goblin(); + + // casts shrink/unshrink spell + wizard.castSpell(goblin::changeSize); + + // casts visible/invisible spell + wizard.castSpell(goblin::changeVisibility); + + // undo and redo casts + wizard.undoLastSpell(); + wizard.redoLastSpell(); +``` + +Here's the whole example in action. + +```java +var wizard = new Wizard(); +var goblin = new Goblin(); + +goblin.printStatus(); +wizard.castSpell(goblin::changeSize); +goblin.printStatus(); + +wizard.castSpell(goblin::changeVisibility); +goblin.printStatus(); + +wizard.undoLastSpell(); +goblin.printStatus(); + +wizard.undoLastSpell(); +goblin.printStatus(); + +wizard.redoLastSpell(); +goblin.printStatus(); + +wizard.redoLastSpell(); +goblin.printStatus(); +``` + +Here's the program output: + +```java +Goblin, [size=normal] [visibility=visible] +Goblin, [size=small] [visibility=visible] +Goblin, [size=small] [visibility=invisible] +Goblin, [size=small] [visibility=visible] +Goblin, [size=normal] [visibility=visible] +Goblin, [size=small] [visibility=visible] +Goblin, [size=small] [visibility=invisible] +``` + +### Class diagram + +![alt text](./etc/command.png "Command") + +### Applicability + +Use the Command pattern when you want to: + +* Parameterize objects by an action to perform. You can express such parameterization in a +procedural language with a callback function, that is, a function that's registered somewhere to be +called at a later point. Commands are an object-oriented replacement for callbacks. +* Specify, queue, and execute requests at different times. A Command object can have a lifetime +independent of the original request. If the receiver of a request can be represented in an address +space-independent way, then you can transfer a command object for the request to a different process +and fulfill the request there. +* Support undo. The Command's execute operation can store state for reversing its effects in the +command itself. The Command interface must have an added un-execute operation that reverses the +effects of a previous call to execute. The executed commands are stored in a history list. +Unlimited-level undo and redo is achieved by traversing this list backwards and forwards calling +un-execute and execute, respectively. +* Support logging changes so that they can be reapplied in case of a system crash. By augmenting the +Command interface with load and store operations, you can keep a persistent log of changes. +Recovering from a crash involves reloading logged commands from disk and re-executing them with +the execute operation. +* Structure a system around high-level operations build on primitive operations. Such a structure is +common in information systems that support transactions. A transaction encapsulates a set of changes +to data. The Command pattern offers a way to model transactions. Commands have a common interface, +letting you invoke all transactions the same way. The pattern also makes it easy to extend the +system with new transactions. + +## Typical Use Case + +* To keep a history of requests +* Implement callback functionality +* Implement the undo functionality + +## Real world examples + +* [java.lang.Runnable](http://docs.oracle.com/javase/8/docs/api/java/lang/Runnable.html) +* [org.junit.runners.model.Statement](https://github.com/junit-team/junit4/blob/master/src/main/java/org/junit/runners/model/Statement.java) +* [Netflix Hystrix](https://github.com/Netflix/Hystrix/wiki) +* [javax.swing.Action](http://docs.oracle.com/javase/8/docs/api/javax/swing/Action.html) + +### Credits + +* [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/gp/product/0201633612/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0201633612&linkCode=as2&tag=javadesignpat-20&linkId=675d49790ce11db99d90bde47f1aeb59) +* [Head First Design Patterns: A Brain-Friendly Guide](https://www.amazon.com/gp/product/0596007124/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596007124&linkCode=as2&tag=javadesignpat-20&linkId=6b8b6eea86021af6c8e3cd3fc382cb5b) +* [Refactoring to Patterns](https://www.amazon.com/gp/product/0321213351/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0321213351&linkCode=as2&tag=javadesignpat-20&linkId=2a76fcb387234bc71b1c61150b3cc3a7) +* [J2EE Design Patterns](https://www.amazon.com/gp/product/0596004273/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596004273&linkCode=as2&tag=javadesignpat-20&linkId=f27d2644fbe5026ea448791a8ad09c94) + +## Commander +[⬆](#content) + +--- +layout: pattern +title: Commander +folder: commander +permalink: /patterns/commander/ +categories: Concurrency +tags: + - Cloud distributed +--- + +### Intent + +> Used to handle all problems that can be encountered when doing distributed transactions. + +### Class diagram +![alt text](./etc/commander.urm.png "Commander class diagram") + +### Applicability +This pattern can be used when we need to make commits into 2 (or more) databases to complete transaction, which cannot be done atomically and can thereby create problems. + +### Explanation +Handling distributed transactions can be tricky, but if we choose to not handle it carefully, there could be unwanted consequences. Say, we have an e-commerce website which has a Payment microservice and a Shipping microservice. If the shipping is available currently but payment service is not up, or vice versa, how would we deal with it after having already received the order from the user? +We need a mechanism in place which can handle these kinds of situations. We have to direct the order to either one of the services (in this example, shipping) and then add the order into the database of the other service (in this example, payment), since two databses cannot be updated atomically. If currently unable to do it, there should be a queue where this request can be queued, and there has to be a mechanism which allows for a failure in the queueing as well. All this needs to be done by constant retries while ensuring idempotence (even if the request is made several times, the change should only be applied once) by a commander class, to reach a state of eventual consistency. + +### Credits + +* [https://www.grahamlea.com/2016/08/distributed-transactions-microservices-icebergs/] + +## Composite +[⬆](#content) + +--- +layout: pattern +title: Composite +folder: composite +permalink: /patterns/composite/ +categories: Structural +tags: + - Gang of Four +--- + +### Intent + +Compose objects into tree structures to represent part-whole hierarchies. Composite lets clients +treat individual objects and compositions of objects uniformly. + +### Explanation + +Real world example + +> Every sentence is composed of words which are in turn composed of characters. Each of these +> objects is printable and they can have something printed before or after them like sentence always +> ends with full stop and word always has space before it. + +In plain words + +> Composite pattern lets clients treat the individual objects in a uniform manner. + +Wikipedia says + +> In software engineering, the composite pattern is a partitioning design pattern. The composite +> pattern describes that a group of objects is to be treated in the same way as a single instance of +> an object. The intent of a composite is to "compose" objects into tree structures to represent +> part-whole hierarchies. Implementing the composite pattern lets clients treat individual objects +> and compositions uniformly. + +**Programmatic Example** + +Taking our sentence example from above. Here we have the base class `LetterComposite` and the +different printable types `Letter`, `Word` and `Sentence`. + +```java +public abstract class LetterComposite { + + private final List children = new ArrayList<>(); + + public void add(LetterComposite letter) { + children.add(letter); + } + + public int count() { + return children.size(); + } + + protected void printThisBefore() { + } + + protected void printThisAfter() { + } + + public void print() { + printThisBefore(); + children.forEach(LetterComposite::print); + printThisAfter(); + } +} + +public class Letter extends LetterComposite { + + private final char character; + + public Letter(char c) { + this.character = c; + } + + @Override + protected void printThisBefore() { + System.out.print(character); + } +} + +public class Word extends LetterComposite { + + public Word(List letters) { + letters.forEach(this::add); + } + + public Word(char... letters) { + for (char letter : letters) { + this.add(new Letter(letter)); + } + } + + @Override + protected void printThisBefore() { + System.out.print(" "); + } +} + +public class Sentence extends LetterComposite { + + public Sentence(List words) { + words.forEach(this::add); + } + + @Override + protected void printThisAfter() { + System.out.print("."); + } +} +``` + +Then we have a messenger to carry messages: + +```java +public class Messenger { + + LetterComposite messageFromOrcs() { + + var words = List.of( + new Word('W', 'h', 'e', 'r', 'e'), + new Word('t', 'h', 'e', 'r', 'e'), + new Word('i', 's'), + new Word('a'), + new Word('w', 'h', 'i', 'p'), + new Word('t', 'h', 'e', 'r', 'e'), + new Word('i', 's'), + new Word('a'), + new Word('w', 'a', 'y') + ); + + return new Sentence(words); + + } + + LetterComposite messageFromElves() { + + var words = List.of( + new Word('M', 'u', 'c', 'h'), + new Word('w', 'i', 'n', 'd'), + new Word('p', 'o', 'u', 'r', 's'), + new Word('f', 'r', 'o', 'm'), + new Word('y', 'o', 'u', 'r'), + new Word('m', 'o', 'u', 't', 'h') + ); + + return new Sentence(words); + + } + +} +``` + +And then it can be used as: + +```java +var orcMessage = new Messenger().messageFromOrcs(); +orcMessage.print(); // Where there is a whip there is a way. +var elfMessage = new Messenger().messageFromElves(); +elfMessage.print(); // Much wind pours from your mouth. +``` + +### Class diagram + +![alt text](./etc/composite.urm.png "Composite class diagram") + +### Applicability + +Use the Composite pattern when + +* You want to represent part-whole hierarchies of objects. +* You want clients to be able to ignore the difference between compositions of objects and +individual objects. Clients will treat all objects in the composite structure uniformly. + +## Real world examples + +* [java.awt.Container](http://docs.oracle.com/javase/8/docs/api/java/awt/Container.html) and [java.awt.Component](http://docs.oracle.com/javase/8/docs/api/java/awt/Component.html) +* [Apache Wicket](https://github.com/apache/wicket) component tree, see [Component](https://github.com/apache/wicket/blob/91e154702ab1ff3481ef6cbb04c6044814b7e130/wicket-core/src/main/java/org/apache/wicket/Component.java) and [MarkupContainer](https://github.com/apache/wicket/blob/b60ec64d0b50a611a9549809c9ab216f0ffa3ae3/wicket-core/src/main/java/org/apache/wicket/MarkupContainer.java) + +### Credits + +* [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/gp/product/0201633612/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0201633612&linkCode=as2&tag=javadesignpat-20&linkId=675d49790ce11db99d90bde47f1aeb59) +* [Head First Design Patterns: A Brain-Friendly Guide](https://www.amazon.com/gp/product/0596007124/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596007124&linkCode=as2&tag=javadesignpat-20&linkId=6b8b6eea86021af6c8e3cd3fc382cb5b) +* [Refactoring to Patterns](https://www.amazon.com/gp/product/0321213351/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0321213351&linkCode=as2&tag=javadesignpat-20&linkId=2a76fcb387234bc71b1c61150b3cc3a7) + + +## Converter +[⬆](#content) + +--- +layout: pattern +title: Converter +folder: converter +permalink: /patterns/converter/ +categories: Creational +tags: + - Decoupling +--- + +### Intent + +The purpose of the Converter pattern is to provide a generic, common way of bidirectional +conversion between corresponding types, allowing a clean implementation in which the types do not +need to be aware of each other. Moreover, the Converter pattern introduces bidirectional collection +mapping, reducing a boilerplate code to minimum. + +### Explanation + +Real world example + +> In real world applications it is often the case that database layer consists of entities that need +> to be mapped into DTOs for use on the business logic layer. Similar mapping is done for +> potentially huge amount of classes and we need a generic way to achieve this. + +In plain words + +> Converter pattern makes it easy to map instances of one class into instances of another class. + +**Programmatic Example** + +We need a generic solution for the mapping problem. To achieve this, let's introduce a generic +converter. + +```java +public class Converter { + + private final Function fromDto; + private final Function fromEntity; + + public Converter(final Function fromDto, final Function fromEntity) { + this.fromDto = fromDto; + this.fromEntity = fromEntity; + } + + public final U convertFromDto(final T dto) { + return fromDto.apply(dto); + } + + public final T convertFromEntity(final U entity) { + return fromEntity.apply(entity); + } + + public final List createFromDtos(final Collection dtos) { + return dtos.stream().map(this::convertFromDto).collect(Collectors.toList()); + } + + public final List createFromEntities(final Collection entities) { + return entities.stream().map(this::convertFromEntity).collect(Collectors.toList()); + } +} +``` + +The specialized converters inherit from this base class as follows. + +```java +public class UserConverter extends Converter { + + public UserConverter() { + super(UserConverter::convertToEntity, UserConverter::convertToDto); + } + + private static UserDto convertToDto(User user) { + return new UserDto(user.getFirstName(), user.getLastName(), user.isActive(), user.getUserId()); + } + + private static User convertToEntity(UserDto dto) { + return new User(dto.getFirstName(), dto.getLastName(), dto.isActive(), dto.getEmail()); + } + +} +``` + +Now mapping between `User` and `UserDto` becomes trivial. + +```java +var userConverter = new UserConverter(); +var dtoUser = new UserDto("John", "Doe", true, "whatever[at]wherever.com"); +var user = userConverter.convertFromDto(dtoUser); +``` + +### Class diagram + +![alt text](./etc/converter.png "Converter Pattern") + +### Applicability + +Use the Converter Pattern in the following situations: + +* When you have types that logically correspond with each other and you need to convert entities +between them. +* When you want to provide different ways of types conversions depending on the context. +* Whenever you introduce a DTO (Data transfer object), you will probably need to convert it into the +domain equivalence. + +### Credits + +* [Converter](http://www.xsolve.pl/blog/converter-pattern-in-java-8/) + + +## CQRS +[⬆](#content) + +--- +layout: pattern +title: CQRS +folder: cqrs +permalink: /patterns/cqrs/ +categories: Architectural +tags: + - Performance + - Cloud distributed +--- + +### Intent +CQRS Command Query Responsibility Segregation - Separate the query side from the command side. + +### Class diagram +![alt text](./etc/cqrs.png "CQRS") + +### Applicability +Use the CQRS pattern when + +* You want to scale the queries and commands independently. +* You want to use different data models for queries and commands. Useful when dealing with complex domains. +* You want to use architectures like event sourcing or task based UI. + +### Credits + +* [Greg Young - CQRS, Task Based UIs, Event Sourcing agh!](http://codebetter.com/gregyoung/2010/02/16/cqrs-task-based-uis-event-sourcing-agh/) +* [Martin Fowler - CQRS](https://martinfowler.com/bliki/CQRS.html) +* [Oliver Wolf - CQRS for Great Good](https://www.youtube.com/watch?v=Ge53swja9Dw) +* [Command and Query Responsibility Segregation (CQRS) pattern](https://docs.microsoft.com/en-us/azure/architecture/patterns/cqrs) + + +## DAO +[⬆](#content) + +--- +layout: pattern +title: Data Access Object +folder: dao +permalink: /patterns/dao/ +categories: Architectural +tags: + - Data access +--- + +### Intent + +Object provides an abstract interface to some type of database or other persistence mechanism. + +### Explanation + +Real world example + +> There's a set of customers that need to be persisted to database. Additionally we need the whole +> set of CRUD (create/read/update/delete) operations so we can operate on customers easily. + +In plain words + +> DAO is an interface we provide over the base persistence mechanism. + +Wikipedia says + +> In computer software, a data access object (DAO) is a pattern that provides an abstract interface +> to some type of database or other persistence mechanism. + +**Programmatic Example** + +Walking through our customers example, here's the basic `Customer` entity. + +```java +public class Customer { + + private int id; + private String firstName; + private String lastName; + + public Customer(int id, String firstName, String lastName) { + this.id = id; + this.firstName = firstName; + this.lastName = lastName; + } + // getters and setters -> + ... +} +``` + +Here's the `CustomerDao` interface and two different implementations for it. `InMemoryCustomerDao` +keeps a simple map of customers in memory while `DBCustomerDao` is the real RDBMS implementation. + +```java +public interface CustomerDao { + + Stream getAll() throws Exception; + + Optional getById(int id) throws Exception; + + boolean add(Customer customer) throws Exception; + + boolean update(Customer customer) throws Exception; + + boolean delete(Customer customer) throws Exception; +} + +public class InMemoryCustomerDao implements CustomerDao { + + private final Map idToCustomer = new HashMap<>(); + + // implement the interface using the map + ... +} + +public class DbCustomerDao implements CustomerDao { + + private static final Logger LOGGER = LoggerFactory.getLogger(DbCustomerDao.class); + + private final DataSource dataSource; + + public DbCustomerDao(DataSource dataSource) { + this.dataSource = dataSource; + } + + // implement the interface using the data source + ... +``` + +Finally here's how we use our DAO to manage customers. + +```java + final var dataSource = createDataSource(); + createSchema(dataSource); + final var customerDao = new DbCustomerDao(dataSource); + + addCustomers(customerDao); + log.info(ALL_CUSTOMERS); + try (var customerStream = customerDao.getAll()) { + customerStream.forEach((customer) -> log.info(customer.toString())); + } + log.info("customerDao.getCustomerById(2): " + customerDao.getById(2)); + final var customer = new Customer(4, "Dan", "Danson"); + customerDao.add(customer); + log.info(ALL_CUSTOMERS + customerDao.getAll()); + customer.setFirstName("Daniel"); + customer.setLastName("Danielson"); + customerDao.update(customer); + log.info(ALL_CUSTOMERS); + try (var customerStream = customerDao.getAll()) { + customerStream.forEach((cust) -> log.info(cust.toString())); + } + customerDao.delete(customer); + log.info(ALL_CUSTOMERS + customerDao.getAll()); + + deleteSchema(dataSource); +``` + +The program output: + +```java +customerDao.getAllCustomers(): +Customer{id=1, firstName='Adam', lastName='Adamson'} +Customer{id=2, firstName='Bob', lastName='Bobson'} +Customer{id=3, firstName='Carl', lastName='Carlson'} +customerDao.getCustomerById(2): Optional[Customer{id=2, firstName='Bob', lastName='Bobson'}] +customerDao.getAllCustomers(): java.util.stream.ReferencePipeline$Head@7cef4e59 +customerDao.getAllCustomers(): +Customer{id=1, firstName='Adam', lastName='Adamson'} +Customer{id=2, firstName='Bob', lastName='Bobson'} +Customer{id=3, firstName='Carl', lastName='Carlson'} +Customer{id=4, firstName='Daniel', lastName='Danielson'} +customerDao.getAllCustomers(): java.util.stream.ReferencePipeline$Head@2db0f6b2 +customerDao.getAllCustomers(): +Customer{id=1, firstName='Adam', lastName='Adamson'} +Customer{id=2, firstName='Bob', lastName='Bobson'} +Customer{id=3, firstName='Carl', lastName='Carlson'} +customerDao.getCustomerById(2): Optional[Customer{id=2, firstName='Bob', lastName='Bobson'}] +customerDao.getAllCustomers(): java.util.stream.ReferencePipeline$Head@12c8a2c0 +customerDao.getAllCustomers(): +Customer{id=1, firstName='Adam', lastName='Adamson'} +Customer{id=2, firstName='Bob', lastName='Bobson'} +Customer{id=3, firstName='Carl', lastName='Carlson'} +Customer{id=4, firstName='Daniel', lastName='Danielson'} +customerDao.getAllCustomers(): java.util.stream.ReferencePipeline$Head@6ec8211c +``` + +### Class diagram + +![alt text](./etc/dao.png "Data Access Object") + +### Applicability + +Use the Data Access Object in any of the following situations: + +* When you want to consolidate how the data layer is accessed. +* When you want to avoid writing multiple data retrieval/persistence layers. + +### Credits + +* [J2EE Design Patterns](https://www.amazon.com/gp/product/0596004273/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596004273&linkCode=as2&tag=javadesignpat-20&linkId=48d37c67fb3d845b802fa9b619ad8f31) + + +## Data Bus +[⬆](#content) + +--- +layout: pattern +title: Data Bus +folder: data-bus +permalink: /patterns/data-bus/ + +categories: Architectural +tags: + - Decoupling +--- + +### Intent + +Allows send of messages/events between components of an application +without them needing to know about each other. They only need to know +about the type of the message/event being sent. + +### Class diagram +![data bus pattern uml diagram](./etc/data-bus.urm.png "Data Bus pattern") + +### Applicability +Use Data Bus pattern when + +* you want your components to decide themselves which messages/events they want to receive +* you want to have many-to-many communication +* you want your components to know nothing about each other + +## Related Patterns +Data Bus is similar to + +* Mediator pattern with Data Bus Members deciding for themselves if they want to accept any given message +* Observer pattern but supporting many-to-many communication +* Publish/Subscribe pattern with the Data Bus decoupling the publisher and the subscriber + +## Data Locality +[⬆](#content) + +--- +layout: pattern +title: Data Locality +folder: data-locality +permalink: /patterns/data-locality/ +categories: Behavioral +tags: + - Game programming + - Performance +--- + +### Intent +Accelerate memory access by arranging data to take advantage of CPU caching. + +Modern CPUs have caches to speed up memory access. These can access memory adjacent to recently accessed memory much quicker. Take advantage of that to improve performance by increasing data locality keeping data in contiguous memory in the order that you process it. + +### Class diagram +![alt text](./etc/data-locality.urm.png "Data Locality pattern class diagram") + +### Applicability + +* Like most optimizations, the first guideline for using the Data Locality pattern is when you have a performance problem. +* With this pattern specifically, you’ll also want to be sure your performance problems are caused by cache misses. + +## Real world example + +* The [Artemis](http://gamadu.com/artemis/) game engine is one of the first and better-known frameworks that uses simple IDs for game entities. + +### Credits + +* [Game Programming Patterns Optimization Patterns: Data Locality](http://gameprogrammingpatterns.com/data-locality.html)--- + + +## Data Mapper +[⬆](#content) + +--- +layout: pattern +title: Data Mapper +folder: data-mapper +permalink: /patterns/data-mapper/ +categories: Architectural +tags: + - Decoupling +--- + +### Intent +A layer of mappers that moves data between objects and a database while keeping them independent of each other and the mapper itself + +### Class diagram +![alt text](./etc/data-mapper.png "Data Mapper") + +### Applicability +Use the Data Mapper in any of the following situations + +* when you want to decouple data objects from DB access layer +* when you want to write multiple data retrieval/persistence implementations + +### Credits + +* [Data Mapper](http://richard.jp.leguen.ca/tutoring/soen343-f2010/tutorials/implementing-data-mapper/) + +## Data Transfer Object +[⬆](#content) + +--- +layout: pattern +title: Data Transfer Object +folder: data-transfer-object +permalink: /patterns/data-transfer-object/ +categories: Architectural +tags: + - Performance +--- + +### Intent + +Pass data with multiple attributes in one shot from client to server, to avoid multiple calls to +remote server. + +### Explanation + +Real world example + +> We need to fetch information about customers from remote database. Instead of querying the +> attributes one at a time, we use DTOs to transfer all the relevant attributes in a single shot. + +In plain words + +> Using DTO relevant information can be fetched with a single backend query. + +Wikipedia says + +> In the field of programming a data transfer object (DTO) is an object that carries data between +> processes. The motivation for its use is that communication between processes is usually done +> resorting to remote interfaces (e.g. web services), where each call is an expensive operation. +> Because the majority of the cost of each call is related to the round-trip time between the client +> and the server, one way of reducing the number of calls is to use an object (the DTO) that +> aggregates the data that would have been transferred by the several calls, but that is served by +> one call only. + +**Programmatic Example** + +Let's first introduce our simple `CustomerDTO` class. + +```java +public class CustomerDto { + private final String id; + private final String firstName; + private final String lastName; + + public CustomerDto(String id, String firstName, String lastName) { + this.id = id; + this.firstName = firstName; + this.lastName = lastName; + } + + public String getId() { + return id; + } + + public String getFirstName() { + return firstName; + } + + public String getLastName() { + return lastName; + } +} +``` + +`CustomerResource` class acts as the server for customer information. + +```java +public class CustomerResource { + private final List customers; + + public CustomerResource(List customers) { + this.customers = customers; + } + + public List getAllCustomers() { + return customers; + } + + public void save(CustomerDto customer) { + customers.add(customer); + } + + public void delete(String customerId) { + customers.removeIf(customer -> customer.getId().equals(customerId)); + } +} +``` + +Now fetching customer information is easy since we have the DTOs. + +```java + var allCustomers = customerResource.getAllCustomers(); + allCustomers.forEach(customer -> LOGGER.info(customer.getFirstName())); + // Kelly + // Alfonso +``` + +### Class diagram + +![alt text](./etc/data-transfer-object.urm.png "data-transfer-object") + +### Applicability + +Use the Data Transfer Object pattern when: + +* The client is asking for multiple information. And the information is related. +* When you want to boost the performance to get resources. +* You want reduced number of remote calls. + +### Credits + +* [Design Pattern - Transfer Object Pattern](https://www.tutorialspoint.com/design_pattern/transfer_object_pattern.htm) +* [Data Transfer Object](https://msdn.microsoft.com/en-us/library/ff649585.aspx) +* [J2EE Design Patterns](https://www.amazon.com/gp/product/0596004273/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596004273&linkCode=as2&tag=javadesignpat-20&linkId=f27d2644fbe5026ea448791a8ad09c94) +* [Patterns of Enterprise Application Architecture](https://www.amazon.com/gp/product/0321127420/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0321127420&linkCode=as2&tag=javadesignpat-20&linkId=014237a67c9d46f384b35e10151956bd) + + +## Decorator +[⬆](#content) + +--- +layout: pattern +title: Decorator +folder: decorator +permalink: /patterns/decorator/ +categories: Structural +tags: + - Gang Of Four + - Extensibility +--- + +### Also known as + +Wrapper + +### Intent + +Attach additional responsibilities to an object dynamically. Decorators provide a flexible +alternative to subclassing for extending functionality. + +### Explanation + +Real world example + +> There is an angry troll living in the nearby hills. Usually it goes bare handed but sometimes it +> has a weapon. To arm the troll it's not necessary to create a new troll but to decorate it +> dynamically with a suitable weapon. + +In plain words + +> Decorator pattern lets you dynamically change the behavior of an object at run time by wrapping +> them in an object of a decorator class. + +Wikipedia says + +> In object-oriented programming, the decorator pattern is a design pattern that allows behavior to +> be added to an individual object, either statically or dynamically, without affecting the behavior +> of other objects from the same class. The decorator pattern is often useful for adhering to the +> Single Responsibility Principle, as it allows functionality to be divided between classes with +> unique areas of concern. + +**Programmatic Example** + +Let's take the troll example. First of all we have a `SimpleTroll` implementing the `Troll` +interface: + +```java +public interface Troll { + void attack(); + int getAttackPower(); + void fleeBattle(); +} + +public class SimpleTroll implements Troll { + + private static final Logger LOGGER = LoggerFactory.getLogger(SimpleTroll.class); + + @Override + public void attack() { + LOGGER.info("The troll tries to grab you!"); + } + + @Override + public int getAttackPower() { + return 10; + } + + @Override + public void fleeBattle() { + LOGGER.info("The troll shrieks in horror and runs away!"); + } +} +``` + +Next we want to add club for the troll. We can do it dynamically by using a decorator: + +```java +public class ClubbedTroll implements Troll { + + private static final Logger LOGGER = LoggerFactory.getLogger(ClubbedTroll.class); + + private final Troll decorated; + + public ClubbedTroll(Troll decorated) { + this.decorated = decorated; + } + + @Override + public void attack() { + decorated.attack(); + LOGGER.info("The troll swings at you with a club!"); + } + + @Override + public int getAttackPower() { + return decorated.getAttackPower() + 10; + } + + @Override + public void fleeBattle() { + decorated.fleeBattle(); + } +} +``` + +Here's the troll in action: + +```java +// simple troll +var troll = new SimpleTroll(); +troll.attack(); // The troll tries to grab you! +troll.fleeBattle(); // The troll shrieks in horror and runs away! + +// change the behavior of the simple troll by adding a decorator +var clubbedTroll = new ClubbedTroll(troll); +clubbedTroll.attack(); // The troll tries to grab you! The troll swings at you with a club! +clubbedTroll.fleeBattle(); // The troll shrieks in horror and runs away! +``` + +Program output: + +```java +The troll tries to grab you! +The troll shrieks in horror and runs away! +The troll tries to grab you! The troll swings at you with a club! +The troll shrieks in horror and runs away! +``` + +### Class diagram + +![alt text](./etc/decorator.urm.png "Decorator pattern class diagram") + +### Applicability + +Decorator is used to: + +* Add responsibilities to individual objects dynamically and transparently, that is, without +affecting other objects. +* 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. + +### Tutorial + +* [Decorator Pattern Tutorial](https://www.journaldev.com/1540/decorator-design-pattern-in-java-example) + +## 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](https://www.amazon.com/gp/product/0201633612/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0201633612&linkCode=as2&tag=javadesignpat-20&linkId=675d49790ce11db99d90bde47f1aeb59) +* [Functional Programming in Java: Harnessing the Power of Java 8 Lambda Expressions](https://www.amazon.com/gp/product/1937785467/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1937785467&linkCode=as2&tag=javadesignpat-20&linkId=7e4e2fb7a141631491534255252fd08b) +* [J2EE Design Patterns](https://www.amazon.com/gp/product/0596004273/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596004273&linkCode=as2&tag=javadesignpat-20&linkId=48d37c67fb3d845b802fa9b619ad8f31) +* [Head First Design Patterns: A Brain-Friendly Guide](https://www.amazon.com/gp/product/0596007124/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596007124&linkCode=as2&tag=javadesignpat-20&linkId=6b8b6eea86021af6c8e3cd3fc382cb5b) +* [Refactoring to Patterns](https://www.amazon.com/gp/product/0321213351/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0321213351&linkCode=as2&tag=javadesignpat-20&linkId=2a76fcb387234bc71b1c61150b3cc3a7) +* [J2EE Design Patterns](https://www.amazon.com/gp/product/0596004273/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596004273&linkCode=as2&tag=javadesignpat-20&linkId=f27d2644fbe5026ea448791a8ad09c94) + + +## Delegation +[⬆](#content) + +--- +layout: pattern +title: Delegation +folder: delegation +permalink: /patterns/delegation/ +categories: Structural +tags: + - Decoupling +--- + +### Also known as +Proxy Pattern + +### Intent +It is a technique where an object expresses certain behavior to the outside but in +reality delegates responsibility for implementing that behaviour to an associated object. + +### Class diagram +![alt text](./etc/delegation.png "Delegate") + +### Applicability +Use the Delegate pattern in order to achieve the following + +* Reduce the coupling of methods to their class +* Components that behave identically, but realize that this situation can change in the future. + +### Credits + +* [Delegate Pattern: Wikipedia ](https://en.wikipedia.org/wiki/Delegation_pattern) +* [Proxy Pattern: Wikipedia ](https://en.wikipedia.org/wiki/Proxy_pattern) + +## Dependency Injection +[⬆](#content) + +--- +layout: pattern +title: Dependency Injection +folder: dependency-injection +permalink: /patterns/dependency-injection/ +categories: Creational +tags: + - Decoupling +--- + +### Intent + +Dependency Injection is a software design pattern in which one or more dependencies (or services) +are injected, or passed by reference, into a dependent object (or client) and are made part of the +client's state. The pattern separates the creation of a client's dependencies from its own behavior, +which allows program designs to be loosely coupled and to follow the inversion of control and single +responsibility principles. + +### Explanation + +Real world example + +> The old wizard likes to fill his pipe and smoke tobacco once in a while. However, he doesn't want +> to depend on a single tobacco brand only but likes to be able to enjoy them all interchangeably. + +In plain words + +> Dependency Injection separates creation of client's dependencies from its own behavior. + +Wikipedia says + +> In software engineering, dependency injection is a technique in which an object receives other +> objects that it depends on. These other objects are called dependencies. + +**Programmatic Example** + +Let's first introduce the `Tobacco` interface and the concrete brands. + +```java +public abstract class Tobacco { + + private static final Logger LOGGER = LoggerFactory.getLogger(Tobacco.class); + + public void smoke(Wizard wizard) { + LOGGER.info("{} smoking {}", wizard.getClass().getSimpleName(), + this.getClass().getSimpleName()); + } +} + +public class SecondBreakfastTobacco extends Tobacco { +} + +public class RivendellTobacco extends Tobacco { +} + +public class OldTobyTobacco extends Tobacco { +} +``` + +Next here's the `Wizard` class hierarchy. + +```java +public interface Wizard { + + void smoke(); +} + +public class AdvancedWizard implements Wizard { + + private final Tobacco tobacco; + + public AdvancedWizard(Tobacco tobacco) { + this.tobacco = tobacco; + } + + @Override + public void smoke() { + tobacco.smoke(this); + } +} +``` + +And lastly we can show how easy it is to give the old wizard any brand of tobacco. + +```java + var advancedWizard = new AdvancedWizard(new SecondBreakfastTobacco()); + advancedWizard.smoke(); +``` + +### Class diagram + +![alt text](./etc/dependency-injection.png "Dependency Injection") + +### Applicability + +Use the Dependency Injection pattern when: + +* When you need to remove knowledge of concrete implementation from object. +* To enable unit testing of classes in isolation using mock objects or stubs. + +### Credits + +* [Dependency Injection Principles, Practices, and Patterns](https://www.amazon.com/gp/product/161729473X/ref=as_li_qf_asin_il_tl?ie=UTF8&tag=javadesignpat-20&creative=9325&linkCode=as2&creativeASIN=161729473X&linkId=57079257a5c7d33755493802f3b884bd) +* [Clean Code: A Handbook of Agile Software Craftsmanship](https://www.amazon.com/gp/product/0132350882/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0132350882&linkCode=as2&tag=javadesignpat-20&linkId=2c390d89cc9e61c01b9e7005c7842871) +* [Java 9 Dependency Injection: Write loosely coupled code with Spring 5 and Guice](https://www.amazon.com/gp/product/1788296257/ref=as_li_tl?ie=UTF8&tag=javadesignpat-20&camp=1789&creative=9325&linkCode=as2&creativeASIN=1788296257&linkId=4e9137a3bf722a8b5b156cce1eec0fc1) +* [Google Guice Tutorial: Open source Java based dependency injection framework](https://www.amazon.com/gp/product/B083P7DZ8M/ref=as_li_tl?ie=UTF8&tag=javadesignpat-20&camp=1789&creative=9325&linkCode=as2&creativeASIN=B083P7DZ8M&linkId=04f0f902c877921e45215b624a124bfe) + + +## Dirty Flag +[⬆](#content) + +--- +layout: pattern +title: Dirty Flag +folder: dirty-flag +permalink: /patterns/dirty-flag/ +categories: Behavioral +tags: + - Game programming + - Performance +--- + +### Also known as +* IsDirty pattern + +### Intent +To avoid expensive re-acquisition of resources. The resources retain their identity, are kept in some +fast-access storage, and are re-used to avoid having to acquire them again. + +### Class diagram +![alt text](./etc/dirty-flag.png "Dirty Flag") + +### Applicability +Use the Dirty Flag pattern when + +* Repetitious acquisition, initialization, and release of the same resource causes unnecessary performance overhead. + +### Credits + +* [Design Patterns: Dirty Flag](https://www.takeupcode.com/podcast/89-design-patterns-dirty-flag/) +* [J2EE Design Patterns](https://www.amazon.com/gp/product/0596004273/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596004273&linkCode=as2&tag=javadesignpat-20&linkId=48d37c67fb3d845b802fa9b619ad8f31) + +## Double Buffer +[⬆](#content) + +--- +layout: pattern +title: Double Buffer +folder: double-buffer +permalink: /patterns/double-buffer/ +categories: Behavioral +tags: + - Performance + - Game programming +--- + +### Intent +Double buffering is a term used to describe a device that has two buffers. The usage of multiple buffers increases the overall throughput of a device and helps prevents bottlenecks. This example shows using double buffer pattern on graphics. It is used to show one image or frame while a separate frame is being buffered to be shown next. This method makes animations and games look more realistic than the same done in a single buffer mode. + +### Class diagram +![alt text](./etc/double-buffer.urm.png "Double Buffer pattern class diagram") + +### Applicability +This pattern is one of those ones where you’ll know when you need it. If you have a system that lacks double buffering, it will probably look visibly wrong (tearing, etc.) or will behave incorrectly. But saying, “you’ll know when you need it” doesn’t give you much to go on. More specifically, this pattern is appropriate when all of these are true: + +- We have some state that is being modified incrementally. +- That same state may be accessed in the middle of modification. +- We want to prevent the code that’s accessing the state from seeing the work in progress. +- We want to be able to read the state and we don’t want to have to wait while it’s being written. + +### Credits + +* [Game Programming Patterns - Double Buffer]([http://gameprogrammingpatterns.com/double-buffer.html](http://gameprogrammingpatterns.com/double-buffer.html)) + +## Double Checked Locking +[⬆](#content) + +--- +layout: pattern +title: Double Checked Locking +folder: double-checked-locking +permalink: /patterns/double-checked-locking/ +categories: Idiom +tags: + - Performance +--- + +### Intent +Reduce the overhead of acquiring a lock by first testing the +locking criterion (the "lock hint") without actually acquiring the lock. Only +if the locking criterion check indicates that locking is required does the +actual locking logic proceed. + +### Class diagram +![alt text](./etc/double_checked_locking_1.png "Double Checked Locking") + +### Applicability +Use the Double Checked Locking pattern when + +* there is a concurrent access in object creation, e.g. singleton, where you want to create single instance of the same class and checking if it's null or not maybe not be enough when there are two or more threads that checks if instance is null or not. +* there is a concurrent access on a method where method's behaviour changes according to the some constraints and these constraint change within this method. + +## Double Dispatch +[⬆](#content) + +--- +layout: pattern +title: Double Dispatch +folder: double-dispatch +permalink: /patterns/double-dispatch/ +categories: Idiom +tags: + - Extensibility +--- + +### Intent +Double Dispatch pattern is a way to create maintainable dynamic +behavior based on receiver and parameter types. + +### Class diagram +![alt text](./etc/double-dispatch.png "Double Dispatch") + +### Applicability +Use the Double Dispatch pattern when + +* the dynamic behavior is not defined only based on receiving object's type but also on the receiving method's parameter type. + +## Real world examples + +* [ObjectOutputStream](https://docs.oracle.com/javase/8/docs/api/java/io/ObjectOutputStream.html) + +## EIP Aggregator +[⬆](#content) + +--- +layout: pattern +title: EIP Aggregator +folder: eip-aggregator +permalink: /patterns/eip-aggregator/ +categories: Integration +tags: + - Enterprise Integration Pattern +--- + +### Intent +Sometimes in enterprise systems there is a need to group incoming data in order to process it as a whole. For example +you may need to gather offers and after defined number of offers has been received you would like to choose the one with +the best parameters. + +Aggregator allows you to merge messages based on defined criteria and parameters. It gathers original messages, +applies aggregation strategy and upon fulfilling given criteria, releasing merged messages. + +## Diagram +![alt text](./etc/aggregator.gif "Splitter") + +### Applicability +Use the Aggregator pattern when + +* You need to combine multiple incoming messages +* You want to process grouped data + +### Credits + +* [Gregor Hohpe, Bobby Woolf - Enterprise Integration Patterns](http://www.enterpriseintegrationpatterns.com/patterns/messaging/Aggregator.html) +* [Apache Camel - Documentation](http://camel.apache.org/aggregator2.html) +* [Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions](https://www.amazon.com/gp/product/0321200683/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0321200683&linkCode=as2&tag=javadesignpat-20&linkId=122e0cff74eedd004cc81a3ecfa623cf) + +## EIP Message Channel +[⬆](#content) + +--- +layout: pattern +title: EIP Message Channel +folder: eip-message-channel +permalink: /patterns/eip-message-channel/ +categories: Integration +tags: + - Enterprise Integration Pattern +--- + +### Intent +When two applications communicate using a messaging system they do it by using logical addresses +of the system, so called Message Channels. + +### Class diagram +![alt text](./etc/message-channel.png "Message Channel") + +### Applicability +Use the Message Channel pattern when + +* two or more applications need to communicate using a messaging system + +## Real world examples + +* [akka-camel](http://doc.akka.io/docs/akka/snapshot/scala/camel.html) +* [Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions](https://www.amazon.com/gp/product/0321200683/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0321200683&linkCode=as2&tag=javadesignpat-20&linkId=122e0cff74eedd004cc81a3ecfa623cf) + + +## EIP Publish Subscribe +[⬆](#content) + +--- +layout: pattern +title: EIP Publish Subscribe +folder: eip-publish-subscribe +permalink: /patterns/eip-publish-subscribe/ +categories: Integration +tags: + - Enterprise Integration Pattern +--- + +### Intent +Broadcast messages from sender to all the interested receivers. + +### Class diagram +![alt text](./etc/publish-subscribe.png "Publish Subscribe Channel") + +### Applicability +Use the Publish Subscribe Channel pattern when + +* two or more applications need to communicate using a messaging system for broadcasts. + +### Credits + +* [J2EE Design Patterns](https://www.amazon.com/gp/product/0596004273/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596004273&linkCode=as2&tag=javadesignpat-20&linkId=48d37c67fb3d845b802fa9b619ad8f31) +* [Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions](https://www.amazon.com/gp/product/0321200683/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0321200683&linkCode=as2&tag=javadesignpat-20&linkId=122e0cff74eedd004cc81a3ecfa623cf) + + +## EIP Splitter +[⬆](#content) + +--- +layout: pattern +title: EIP Splitter +folder: eip-splitter +permalink: /patterns/eip-splitter/ +categories: Integration +tags: + - Enterprise Integration Pattern +--- + +### 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. + +## Diagram +![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) +* [Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions](https://www.amazon.com/gp/product/0321200683/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0321200683&linkCode=as2&tag=javadesignpat-20&linkId=122e0cff74eedd004cc81a3ecfa623cf) + + +## EIP Wire Tap +[⬆](#content) + +--- +layout: pattern +title: EIP Wire Tap +folder: eip-wire-tap +permalink: /patterns/eip-wire-tap/ +categories: Integration +tags: + - Enterprise Integration Pattern +--- + +### Intent +In most integration cases there is a need to monitor the messages flowing through the system. It is usually achieved +by intercepting the message and redirecting it to a different location like console, filesystem or the database. +It is important that such functionality should not modify the original message and influence the processing path. + +## Diagram +![alt text](./etc/wiretap.gif "Wire Tap") + +### Applicability +Use the Wire Tap pattern when + +* You need to monitor messages flowing through the system +* You need to redirect the same, unchanged message to two different endpoints/paths + +### Credits + +* [Gregor Hohpe, Bobby Woolf - Enterprise Integration Patterns](http://www.enterpriseintegrationpatterns.com/patterns/messaging/WireTap.html) +* [Apache Camel - Documentation](http://camel.apache.org/wire-tap.html) +* [Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions](https://www.amazon.com/gp/product/0321200683/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0321200683&linkCode=as2&tag=javadesignpat-20&linkId=122e0cff74eedd004cc81a3ecfa623cf) + + +## Event Aggregator +[⬆](#content) + +--- +layout: pattern +title: Event Aggregator +folder: event-aggregator +permalink: /patterns/event-aggregator/ +categories: Structural +tags: + - Reactive +--- + +### Intent +A system with lots of objects can lead to complexities when a +client wants to subscribe to events. The client has to find and register for +each object individually, if each object has multiple events then each event +requires a separate subscription. An Event Aggregator acts as a single source +of events for many objects. It registers for all the events of the many objects +allowing clients to register with just the aggregator. + +### Class diagram +![alt text](./etc/classes.png "Event Aggregator") + +### Applicability +Use the Event Aggregator pattern when + +* Event Aggregator is a good choice when you have lots of objects that are + potential event sources. Rather than have the observer deal with registering + with them all, you can centralize the registration logic to the Event + Aggregator. As well as simplifying registration, a Event Aggregator also + simplifies the memory management issues in using observers. + +### Credits + +* [Martin Fowler - Event Aggregator](http://martinfowler.com/eaaDev/EventAggregator.html) + +## Event Asynchronous +[⬆](#content) + +--- +layout: pattern +title: Event Asynchronous +folder: event-asynchronous +permalink: /patterns/event-asynchronous/ +categories: Concurrency +tags: + - Reactive +--- + +### Intent +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. + +### Class diagram +![alt text](./etc/event-asynchronous.png "Event-based Asynchronous") + +### Applicability +Use the Event-based Asynchronous pattern(s) when + +* Time-consuming tasks are needed to run in the background without disrupting the current application. + +### Credits + +* [Event-based Asynchronous Pattern Overview](https://msdn.microsoft.com/en-us/library/wewwczdw%28v=vs.110%29.aspx?f=255&MSPPError=-2147217396) + +## Event Driven Architecture +[⬆](#content) + +--- +layout: pattern +title: Event Driven Architecture +folder: event-driven-architecture +permalink: /patterns/event-driven-architecture/ +categories: Architectural +tags: + - Reactive +--- + +### Intent +Send and notify state changes of your objects to other applications using an Event-driven Architecture. + +### Class diagram +![alt text](./etc/eda.png "Event Driven Architecture") + +### Applicability +Use an Event-driven architecture when + +* you want to create a loosely coupled system +* you want to build a more responsive system +* you want a system that is easier to extend + +## Real world examples + +* SendGrid, an email API, sends events whenever an email is processed, delivered, opened etc... (https://sendgrid.com/docs/API_Reference/Webhooks/event.html) +* Chargify, a billing API, exposes payment activity through various events (https://docs.chargify.com/api-events) +* Amazon's AWS Lambda, lets you execute code in response to events such as changes to Amazon S3 buckets, updates to an Amazon DynamoDB table, or custom events generated by your applications or devices. (https://aws.amazon.com/lambda) +* MySQL runs triggers based on events such as inserts and update events happening on database tables. + +### Credits + +* [Event-driven architecture - Wikipedia](https://en.wikipedia.org/wiki/Event-driven_architecture) +* [Fundamental Components of an Event-Driven Architecture](http://giocc.com/fundamental-components-of-an-event-driven-architecture.html) +* [Real World Applications/Event Driven Applications](https://wiki.haskell.org/Real_World_Applications/Event_Driven_Applications) +* [Event-driven architecture definition](http://searchsoa.techtarget.com/definition/event-driven-architecture) + + +## Event Queue +[⬆](#content) + +--- +layout: pattern +title: Event Queue +folder: event-queue +permalink: /patterns/event-queue/ +categories: Concurrency +tags: + - Game programming +--- + +### Intent +Event Queue is a good pattern if You have a limited accessibility resource (for example: +Audio or Database), but You need to handle all the requests that want to use that. +It puts all the requests in a queue and process them asynchronously. +Gives the resource for the event when it is the next in the queue and in same time +removes it from the queue. + +### Class diagram +![alt text](./etc/model.png "Event Queue") + +### Applicability +Use the Event Queue pattern when + +* You have a limited accessibility resource and the asynchronous process is acceptable to reach that + +### Credits + +* [Mihaly Kuprivecz - Event Queue] (http://gameprogrammingpatterns.com/event-queue.html) + + +## Event Sourcing +[⬆](#content) + +--- +layout: pattern +title: Event Sourcing +folder: event-sourcing +permalink: /patterns/event-sourcing/ +categories: Architectural +tags: + - Performance + - Cloud distributed +--- + +### Intent +Instead of storing just the current state of the data in a domain, use an append-only store to record the full series of actions taken on that data. The store acts as the system of record and can be used to materialize the domain objects. This can simplify tasks in complex domains, by avoiding the need to synchronize the data model and the business domain, while improving performance, scalability, and responsiveness. It can also provide consistency for transactional data, and maintain full audit trails and history that can enable compensating actions. + +### Class diagram +![alt text](./etc/event-sourcing.png "Event Sourcing") + +### Applicability +Use the Event Sourcing pattern when + +* You need very high performance on persisting your application state even your application state have a complex relational data structure +* You need log of changes of your application state and ability to restore a state of any moment in time. +* You need to debug production problems by replaying the past events. + +## Real world examples + +* [The Lmax Architecture](https://martinfowler.com/articles/lmax.html) + +### Credits + +* [Martin Fowler - Event Sourcing](https://martinfowler.com/eaaDev/EventSourcing.html) +* [Event Sourcing in Microsoft's documentation](https://docs.microsoft.com/en-us/azure/architecture/patterns/event-sourcing) +* [Reference 3: Introducing Event Sourcing](https://msdn.microsoft.com/en-us/library/jj591559.aspx) +* [Event Sourcing pattern](https://docs.microsoft.com/en-us/azure/architecture/patterns/event-sourcing) + + +## Execute Around +[⬆](#content) + +--- +layout: pattern +title: Execute Around +folder: execute-around +permalink: /patterns/execute-around/ +categories: Idiom +tags: + - Extensibility +--- + +### Intent + +Execute Around idiom frees the user from certain actions that should always be executed before and +after the business method. A good example of this is resource allocation and deallocation leaving +the user to specify only what to do with the resource. + +### Explanation + +Real world example + +> We need to provide a class that can be used to write text strings to files. To make it easy for +> the user we let our service class open and close the file automatically, the user only has to +> specify what is written into which file. + +In plain words + +> Execute Around idiom handles boilerplate code before and after business method. + +[Stack Overflow](https://stackoverflow.com/questions/341971/what-is-the-execute-around-idiom) says + +> Basically it's the pattern where you write a method to do things which are always required, e.g. +> resource allocation and clean-up, and make the caller pass in "what we want to do with the +> resource". + +**Programmatic Example** + +Let's introduce our file writer class. + +```java +@FunctionalInterface +public interface FileWriterAction { + + void writeFile(FileWriter writer) throws IOException; + +} + +public class SimpleFileWriter { + + public SimpleFileWriter(String filename, FileWriterAction action) throws IOException { + try (var writer = new FileWriter(filename)) { + action.writeFile(writer); + } + } +} +``` + +To utilize the file writer the following code is needed. + +```java + FileWriterAction writeHello = writer -> { + writer.write("Hello"); + writer.append(" "); + writer.append("there!"); + }; + new SimpleFileWriter("testfile.txt", writeHello); +``` + +### Class diagram + +![alt text](./etc/execute-around.png "Execute Around") + +### Applicability + +Use the Execute Around idiom when + +* You use an API that requires methods to be called in pairs such as open/close or +allocate/deallocate. + +### Credits + +* [Functional Programming in Java: Harnessing the Power of Java 8 Lambda Expressions](https://www.amazon.com/gp/product/1937785467/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1937785467&linkCode=as2&tag=javadesignpat-20&linkId=7e4e2fb7a141631491534255252fd08b) + + +## Extension Objects +[⬆](#content) + +--- +layout: pattern +title: Extension objects +folder: extension-objects +permalink: /patterns/extension-objects/ +categories: Behavioral +tags: + - Extensibility +--- + +### Intent +Anticipate that an object’s interface needs to be extended in the future. Additional +interfaces are defined by extension objects. + +### Class diagram +![Extension_objects](./etc/extension_obj.png "Extension objects") + +### Applicability +Use the Extension Objects pattern when: + +* you need to support the addition of new or unforeseen interfaces to existing classes and you don't want to impact clients that don't need this new interface. Extension Objects lets you keep related operations together by defining them in a separate class +* a class representing a key abstraction plays different roles for different clients. The number of roles the class can play should be open-ended. There is a need to preserve the key abstraction itself. For example, a customer object is still a customer object even if different subsystems view it differently. +* a class should be extensible with new behavior without subclassing from it. + +## Real world examples + +* [OpenDoc](https://en.wikipedia.org/wiki/OpenDoc) +* [Object Linking and Embedding](https://en.wikipedia.org/wiki/Object_Linking_and_Embedding) + + +## Facade +[⬆](#content) + +--- +layout: pattern +title: Facade +folder: facade +permalink: /patterns/facade/ +categories: Structural +tags: + - Gang Of Four + - Decoupling +--- + +### Intent + +Provide a unified interface to a set of interfaces in a subsystem. Facade defines a higher-level +interface that makes the subsystem easier to use. + +### Explanation + +Real world example + +> How does a goldmine work? "Well, the miners go down there and dig gold!" you say. That is what you +> believe because you are using a simple interface that goldmine provides on the outside, internally +> it has to do a lot of stuff to make it happen. This simple interface to the complex subsystem is a +> facade. + +In plain words + +> Facade pattern provides a simplified interface to a complex subsystem. + +Wikipedia says + +> A facade is an object that provides a simplified interface to a larger body of code, such as a +> class library. + +**Programmatic Example** + +Let's take our goldmine example from above. Here we have the dwarven mine worker hierarchy. First +there's a base class `DwarvenMineWorker`: + +```java +public abstract class DwarvenMineWorker { + + private static final Logger LOGGER = LoggerFactory.getLogger(DwarvenMineWorker.class); + + public void goToSleep() { + LOGGER.info("{} goes to sleep.", name()); + } + + public void wakeUp() { + LOGGER.info("{} wakes up.", name()); + } + + public void goHome() { + LOGGER.info("{} goes home.", name()); + } + + public void goToMine() { + LOGGER.info("{} goes to the mine.", name()); + } + + private void action(Action action) { + switch (action) { + case GO_TO_SLEEP: + goToSleep(); + break; + case WAKE_UP: + wakeUp(); + break; + case GO_HOME: + goHome(); + break; + case GO_TO_MINE: + goToMine(); + break; + case WORK: + work(); + break; + default: + LOGGER.info("Undefined action"); + break; + } + } + + public void action(Action... actions) { + Arrays.stream(actions).forEach(this::action); + } + + public abstract void work(); + + public abstract String name(); + + enum Action { + GO_TO_SLEEP, WAKE_UP, GO_HOME, GO_TO_MINE, WORK + } +} +``` + +Then we have the concrete dwarf classes `DwarvenTunnelDigger`, `DwarvenGoldDigger` and +`DwarvenCartOperator`: + +```java +public class DwarvenTunnelDigger extends DwarvenMineWorker { + + private static final Logger LOGGER = LoggerFactory.getLogger(DwarvenTunnelDigger.class); + + @Override + public void work() { + LOGGER.info("{} creates another promising tunnel.", name()); + } + + @Override + public String name() { + return "Dwarven tunnel digger"; + } +} + +public class DwarvenGoldDigger extends DwarvenMineWorker { + + private static final Logger LOGGER = LoggerFactory.getLogger(DwarvenGoldDigger.class); + + @Override + public void work() { + LOGGER.info("{} digs for gold.", name()); + } + + @Override + public String name() { + return "Dwarf gold digger"; + } +} + +public class DwarvenCartOperator extends DwarvenMineWorker { + + private static final Logger LOGGER = LoggerFactory.getLogger(DwarvenCartOperator.class); + + @Override + public void work() { + LOGGER.info("{} moves gold chunks out of the mine.", name()); + } + + @Override + public String name() { + return "Dwarf cart operator"; + } +} + +``` + +To operate all these goldmine workers we have the `DwarvenGoldmineFacade`: + +```java +public class DwarvenGoldmineFacade { + + private final List workers; + + public DwarvenGoldmineFacade() { + workers = List.of( + new DwarvenGoldDigger(), + new DwarvenCartOperator(), + new DwarvenTunnelDigger()); + } + + public void startNewDay() { + makeActions(workers, DwarvenMineWorker.Action.WAKE_UP, DwarvenMineWorker.Action.GO_TO_MINE); + } + + public void digOutGold() { + makeActions(workers, DwarvenMineWorker.Action.WORK); + } + + public void endDay() { + makeActions(workers, DwarvenMineWorker.Action.GO_HOME, DwarvenMineWorker.Action.GO_TO_SLEEP); + } + + private static void makeActions(Collection workers, + DwarvenMineWorker.Action... actions) { + workers.forEach(worker -> worker.action(actions)); + } +} +``` + +Now let's use the facade: + +```java +var facade = new DwarvenGoldmineFacade(); +facade.startNewDay(); +facade.digOutGold(); +facade.endDay(); +``` + +Program output: + +```java +// Dwarf gold digger wakes up. +// Dwarf gold digger goes to the mine. +// Dwarf cart operator wakes up. +// Dwarf cart operator goes to the mine. +// Dwarven tunnel digger wakes up. +// Dwarven tunnel digger goes to the mine. +// Dwarf gold digger digs for gold. +// Dwarf cart operator moves gold chunks out of the mine. +// Dwarven tunnel digger creates another promising tunnel. +// Dwarf gold digger goes home. +// Dwarf gold digger goes to sleep. +// Dwarf cart operator goes home. +// Dwarf cart operator goes to sleep. +// Dwarven tunnel digger goes home. +// Dwarven tunnel digger goes to sleep. +``` + +### Class diagram + +![alt text](./etc/facade.urm.png "Facade pattern class diagram") + +### Applicability + +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 customization 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, then you can simplify the dependencies between them by making them +communicate with each other solely through their facades. + +### Credits + +* [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/gp/product/0201633612/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0201633612&linkCode=as2&tag=javadesignpat-20&linkId=675d49790ce11db99d90bde47f1aeb59) +* [Head First Design Patterns: A Brain-Friendly Guide](https://www.amazon.com/gp/product/0596007124/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596007124&linkCode=as2&tag=javadesignpat-20&linkId=6b8b6eea86021af6c8e3cd3fc382cb5b) + +## Factory +[⬆](#content) + +--- +layout: pattern +title: Factory +folder: factory +permalink: /patterns/factory/ +categories: Creational +tags: + - Gang of Four +--- + +### Also known as + +* Simple Factory +* Static Factory Method + +### Intent + +Providing a static method encapsulated in a class called factory, in order to hide the +implementation logic and makes client code focus on usage rather then initialization new objects. + +### Explanation + +Real world example + +> Lets say we have a web application connected to SQLServer, but now we want to switch to Oracle. To +> do so without modifying existing source code, we need to implements Simple Factory pattern, in +> which a static method can be invoked to create connection to a given database. + +Wikipedia says + +> Factory is an object for creating other objects – formally a factory is a function or method that +> returns objects of a varying prototype or class. + +**Programmatic Example** + +We have an interface `Car` and two implementations `Ford` and `Ferrari`. + +```java +public interface Car { + String getDescription(); +} + +public class Ford implements Car { + + static final String DESCRIPTION = "This is Ford."; + + @Override + public String getDescription() { + return DESCRIPTION; + } +} + +public class Ferrari implements Car { + + static final String DESCRIPTION = "This is Ferrari."; + + @Override + public String getDescription() { + return DESCRIPTION; + } +} +``` + +Enumeration above represents types of cars that we support (`Ford` and `Ferrari`). + +```java +public enum CarType { + + FORD(Ford::new), + FERRARI(Ferrari::new); + + private final Supplier constructor; + + CarType(Supplier constructor) { + this.constructor = constructor; + } + + public Supplier getConstructor() { + return this.constructor; + } +} +``` +Then we have the static method `getCar` to create car objects encapsulated in the factory class +`CarsFactory`. + +```java +public class CarsFactory { + + public static Car getCar(CarType type) { + return type.getConstructor().get(); + } +} +``` + +Now on the client code we can create different types of cars using the factory class. + +```java +var car1 = CarsFactory.getCar(CarType.FORD); +var car2 = CarsFactory.getCar(CarType.FERRARI); +LOGGER.info(car1.getDescription()); +LOGGER.info(car2.getDescription()); +``` + +Program output: + +```java +This is Ford. +This Ferrari. +``` + +## Class Diagram + +![alt text](./etc/factory.urm.png "Factory pattern class diagram") + +### Applicability + +Use the Simple Factory pattern when you only care about the creation of a object, not how to create +and manage it. + +Pros + +* Allows keeping all objects creation in one place and avoid of spreading 'new' keyword across codebase. +* Allows to write loosely coupled code. Some of its main advantages include better testability, easy-to-understand code, swappable components, scalability and isolated features. + +Cons + +* The code becomes more complicated than it should be. + +## Real world examples + +* [java.util.Calendar#getInstance()](https://docs.oracle.com/javase/8/docs/api/java/util/Calendar.html#getInstance--) +* [java.util.ResourceBundle#getBundle()](https://docs.oracle.com/javase/8/docs/api/java/util/ResourceBundle.html#getBundle-java.lang.String-) +* [java.text.NumberFormat#getInstance()](https://docs.oracle.com/javase/8/docs/api/java/text/NumberFormat.html#getInstance--) +* [java.nio.charset.Charset#forName()](https://docs.oracle.com/javase/8/docs/api/java/nio/charset/Charset.html#forName-java.lang.String-) +* [java.net.URLStreamHandlerFactory#createURLStreamHandler(String)](https://docs.oracle.com/javase/8/docs/api/java/net/URLStreamHandlerFactory.html) (Returns different singleton objects, depending on a protocol) +* [java.util.EnumSet#of()](https://docs.oracle.com/javase/8/docs/api/java/util/EnumSet.html#of(E)) +* [javax.xml.bind.JAXBContext#createMarshaller()](https://docs.oracle.com/javase/8/docs/api/javax/xml/bind/JAXBContext.html#createMarshaller--) and other similar methods. + +### Related patterns + +* [Factory Method](https://java-design-patterns.com/patterns/factory-method/) +* [Factory Kit](https://java-design-patterns.com/patterns/factory-kit/) +* [Abstract Factory](https://java-design-patterns.com/patterns/abstract-factory/) + + +## Factory Kit +[⬆](#content) + +--- +layout: pattern +title: Factory Kit +folder: factory-kit +permalink: /patterns/factory-kit/ +categories: Creational +tags: + - Extensibility +--- + +### Intent +Define a factory of immutable content with separated builder and factory interfaces. + +### Class diagram +![alt text](./etc/factory-kit.png "Factory Kit") + +### Applicability +Use the Factory Kit pattern when + +* a class can't anticipate the class of objects it must create +* you just want a new instance of a custom builder instead of the global one +* you explicitly want to define types of objects, that factory can build +* you want a separated builder and creator interface + +### Credits + +* [Design Pattern Reloaded by Remi Forax: ](https://www.youtube.com/watch?v=-k2X7guaArU) + +## Factory Method +[⬆](#content) + +--- +layout: pattern +title: Factory Method +folder: factory-method +permalink: /patterns/factory-method/ +categories: Creational +tags: + - Extensibility + - Gang Of Four +--- + +### Also known as + +Virtual Constructor + +### Intent + +Define an interface for creating an object, but let subclasses decide which class to instantiate. +Factory Method lets a class defer instantiation to subclasses. + +### Explanation + +Real world example + +> Blacksmith manufactures weapons. Elves require Elvish weapons and orcs require Orcish weapons. +> Depending on the customer at hand the right type of blacksmith is summoned. + +In plain words + +> It provides a way to delegate the instantiation logic to child classes. + +Wikipedia says + +> In class-based programming, the factory method pattern is a creational pattern that uses factory +> methods to deal with the problem of creating objects without having to specify the exact class of +> the object that will be created. This is done by creating objects by calling a factory method +> — either specified in an interface and implemented by child classes, or implemented in a base +> class and optionally overridden by derived classes—rather than by calling a constructor. + + **Programmatic Example** + +Taking our blacksmith example above. First of all we have a `Blacksmith` interface and some +implementations for it: + +```java +public interface Blacksmith { + Weapon manufactureWeapon(WeaponType weaponType); +} + +public class ElfBlacksmith implements Blacksmith { + public Weapon manufactureWeapon(WeaponType weaponType) { + return ELFARSENAL.get(weaponType); + } +} + +public class OrcBlacksmith implements Blacksmith { + public Weapon manufactureWeapon(WeaponType weaponType) { + return ORCARSENAL.get(weaponType); + } +} +``` + +When the customers come, the correct type of blacksmith is summoned and requested weapons are +manufactured: + +```java +var blacksmith = new ElfBlacksmith(); +blacksmith.manufactureWeapon(WeaponType.SPEAR); +blacksmith.manufactureWeapon(WeaponType.AXE); +``` + +Program output: +```java +// Elven spear +// Elven axe +``` + +### Class diagram + +![alt text](./etc/factory-method.urm.png "Factory Method pattern class diagram") + +### Applicability + +Use the Factory Method pattern when: + +* Class cannot anticipate the class of objects it must create. +* Class wants its subclasses to specify the objects it creates. +* Classes delegate responsibility to one of several helper subclasses, and you want to localize the +knowledge of which helper subclass is the delegate. + +## Real world examples + +* [java.util.Calendar](http://docs.oracle.com/javase/8/docs/api/java/util/Calendar.html#getInstance--) +* [java.util.ResourceBundle](http://docs.oracle.com/javase/8/docs/api/java/util/ResourceBundle.html#getBundle-java.lang.String-) +* [java.text.NumberFormat](http://docs.oracle.com/javase/8/docs/api/java/text/NumberFormat.html#getInstance--) +* [java.nio.charset.Charset](http://docs.oracle.com/javase/8/docs/api/java/nio/charset/Charset.html#forName-java.lang.String-) +* [java.net.URLStreamHandlerFactory](http://docs.oracle.com/javase/8/docs/api/java/net/URLStreamHandlerFactory.html#createURLStreamHandler-java.lang.String-) +* [java.util.EnumSet](https://docs.oracle.com/javase/8/docs/api/java/util/EnumSet.html#of-E-) +* [javax.xml.bind.JAXBContext](https://docs.oracle.com/javase/8/docs/api/javax/xml/bind/JAXBContext.html#createMarshaller--) + +### Credits + +* [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/gp/product/0201633612/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0201633612&linkCode=as2&tag=javadesignpat-20&linkId=675d49790ce11db99d90bde47f1aeb59) +* [Head First Design Patterns: A Brain-Friendly Guide](https://www.amazon.com/gp/product/0596007124/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596007124&linkCode=as2&tag=javadesignpat-20&linkId=6b8b6eea86021af6c8e3cd3fc382cb5b) +* [Refactoring to Patterns](https://www.amazon.com/gp/product/0321213351/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0321213351&linkCode=as2&tag=javadesignpat-20&linkId=2a76fcb387234bc71b1c61150b3cc3a7) + + +## Feature Toggle +[⬆](#content) + + +--- +layout: pattern +title: Feature Toggle +folder: feature-toggle +permalink: /patterns/feature-toggle/ +categories: Behavioral +tags: + - Extensibility +--- + +### Also known as +Feature Flag + +### Intent +Used to switch code execution paths based on properties or groupings. Allowing new features to be released, tested +and rolled out. Allowing switching back to the older feature quickly if needed. It should be noted that this pattern, +can easily introduce code complexity. There is also cause for concern that the old feature that the toggle is eventually +going to phase out is never removed, causing redundant code smells and increased maintainability. + +### Class diagram +![alt text](./etc/feature-toggle.png "Feature Toggle") + +### Applicability +Use the Feature Toggle pattern when + +* Giving different features to different users. +* Rolling out a new feature incrementally. +* Switching between development and production environments. + +### Credits + +* [Martin Fowler 29 October 2010 (2010-10-29).](http://martinfowler.com/bliki/FeatureToggle.html) + +## Filterer +[⬆](#content) + + +--- +layout: pattern +title: Filterer +folder: filterer +permalink: /patterns/filterer/ +description: Design pattern that helps container-like objects to return filtered version of themselves.# short meta description that shows in Google search results +categories: + - Functional +tags: + - Extensibility +--- + +## Name / classification + +Filterer + +### Intent + +The intent of this design pattern is to introduce a functional interface that will add a +functionality for container-like objects to easily return filtered versions of themselves. + +### Explanation + +Real world example + +> We are designing a threat (malware) detection software which can analyze target systems for +> threats that are present in it. In the design we have to take into consideration that new +> Threat types can be added later. Additionally, there is a requirement that the threat detection +> system can filter the detected threats based on different criteria (the target system acts as +> container-like object for threats). + +In plain words + +> Filterer pattern is a design pattern that helps container-like objects return filtered versions +> of themselves. + +**Programmatic Example** + +To model the threat detection example presented above we introduce `Threat` and `ThreatAwareSystem` +interfaces. + +```java +public interface Threat { + String name(); + int id(); + ThreatType type(); +} + +public interface ThreatAwareSystem { + String systemId(); + List threats(); + Filterer filtered(); + +} +``` + +Notice the `filtered` method that returns instance of `Filterer` interface which is defined as: + +```java +@FunctionalInterface +public interface Filterer { + G by(Predicate predicate); +} +``` + +It is used to fulfill the requirement for system to be able to filter itself based on threat +properties. The container-like object (`ThreatAwareSystem` in our case) needs to have a method that +returns an instance of `Filterer`. This helper interface gives ability to covariantly specify a +lower bound of contravariant `Predicate` in the subinterfaces of interfaces representing the +container-like objects. + +In our example we will be able to pass a predicate that takes `? extends Threat` object and +return `? extends ThreatAwareSystem` from `Filtered::by` method. A simple implementation +of `ThreatAwareSystem`: + +```java +public class SimpleThreatAwareSystem implements ThreatAwareSystem { + + private final String systemId; + private final ImmutableList issues; + + public SimpleThreatAwareSystem(final String systemId, final List issues) { + this.systemId = systemId; + this.issues = ImmutableList.copyOf(issues); + } + + @Override + public String systemId() { + return systemId; + } + + @Override + public List threats() { + return new ArrayList<>(issues); + } + + @Override + public Filterer filtered() { + return this::filteredGroup; + } + + private ThreatAwareSystem filteredGroup(Predicate predicate) { + return new SimpleThreatAwareSystem(this.systemId, filteredItems(predicate)); + } + + private List filteredItems(Predicate predicate) { + return this.issues.stream() + .filter(predicate) + .collect(Collectors.toList()); + } +} +``` + +The `filtered` method is overridden to filter the threats list by given predicate. + +Now if we introduce a new subtype of `Threat` interface that adds probability with which given +threat can appear: + +```java +public interface ProbableThreat extends Threat { + double probability(); +} +``` + +We can also introduce a new interface that represents a system that is aware of threats with their +probabilities: + +````java +public interface ProbabilisticThreatAwareSystem extends ThreatAwareSystem { + @Override + List threats(); + + @Override + Filterer filtered(); +} +```` + +Notice how we override the `filtered` method in `ProbabilisticThreatAwareSystem` and specify +different return covariant type by specifying different generic types. Our interfaces are clean and +not cluttered by default implementations. We we will be able to filter +`ProbabilisticThreatAwareSystem` by `ProbableThreat` properties: + +```java +public class SimpleProbabilisticThreatAwareSystem implements ProbabilisticThreatAwareSystem { + + private final String systemId; + private final ImmutableList threats; + + public SimpleProbabilisticThreatAwareSystem(final String systemId, final List threats) { + this.systemId = systemId; + this.threats = ImmutableList.copyOf(threats); + } + + @Override + public String systemId() { + return systemId; + } + + @Override + public List threats() { + return threats; + } + + @Override + public Filterer filtered() { + return this::filteredGroup; + } + + private ProbabilisticThreatAwareSystem filteredGroup(final Predicate predicate) { + return new SimpleProbabilisticThreatAwareSystem(this.systemId, filteredItems(predicate)); + } + + private List filteredItems(final Predicate predicate) { + return this.threats.stream() + .filter(predicate) + .collect(Collectors.toList()); + } +} +``` + +Now if we want filter `ThreatAwareSystem` by threat type we can do: + +```java +Threat rootkit = new SimpleThreat(ThreatType.ROOTKIT, 1, "Simple-Rootkit"); +Threat trojan = new SimpleThreat(ThreatType.TROJAN, 2, "Simple-Trojan"); +List threats = List.of(rootkit, trojan); + +ThreatAwareSystem threatAwareSystem = new SimpleThreatAwareSystem("System-1", threats); + +ThreatAwareSystem rootkitThreatAwareSystem = threatAwareSystem.filtered() + .by(threat -> threat.type() == ThreatType.ROOTKIT); +``` + +Or if we want to filter `ProbabilisticThreatAwareSystem`: + +```java +ProbableThreat malwareTroyan = new SimpleProbableThreat("Troyan-ArcBomb", 1, ThreatType.TROJAN, 0.99); +ProbableThreat rootkit = new SimpleProbableThreat("Rootkit-System", 2, ThreatType.ROOTKIT, 0.8); +List probableThreats = List.of(malwareTroyan, rootkit); + +ProbabilisticThreatAwareSystem simpleProbabilisticThreatAwareSystem =new SimpleProbabilisticThreatAwareSystem("System-1", probableThreats); + +ProbabilisticThreatAwareSystem filtered = simpleProbabilisticThreatAwareSystem.filtered() + .by(probableThreat -> Double.compare(probableThreat.probability(), 0.99) == 0); +``` + +### Class diagram + +![Filterer](./etc/filterer.png "Filterer") + +### Applicability + +Pattern can be used when working with container-like objects that use subtyping, instead of +parametrizing (generics) for extensible class structure. It enables you to easily extend filtering +ability of container-like objects as business requirements change. + +### Tutorials + +* [Article about Filterer pattern posted on it's author's blog](https://blog.tlinkowski.pl/2018/filterer-pattern/) +* [Application of Filterer pattern in domain of text analysis](https://www.javacodegeeks.com/2019/02/filterer-pattern-10-steps.html) + +### Known uses + +One of the uses is present on the blog presented in +[this](https://www.javacodegeeks.com/2019/02/filterer-pattern-10-steps.html) link. It presents how +to use `Filterer` pattern to create text issue analyzer with support for test cases used for unit +testing. + +### Consequences + +Pros: + * You can easily introduce new subtypes for container-like objects and subtypes for objects that are contained within them and still be able to filter easily be new properties of those new subtypes. + +Cons: + * Covariant return types mixed with generics can be sometimes tricky + +### Credits + +* Author of the pattern : [Tomasz Linkowski](https://tlinkowski.pl/) + + +## Fluent Interface +[⬆](#content) + + +--- +layout: pattern +title: Fluent Interface +folder: fluentinterface +permalink: /patterns/fluentinterface/ +categories: Functional +tags: + - Reactive +--- + +### Intent + +A fluent interface provides an easy-readable, flowing interface, that often mimics a domain specific +language. Using this pattern results in code that can be read nearly as human language. + +### Explanation + +The Fluent Interface pattern is useful when you want to provide an easy readable, flowing API. Those +interfaces tend to mimic domain specific languages, so they can nearly be read as human languages. + +A fluent interface can be implemented using any of + + * Method chaining - calling a method returns some object on which further methods can be called. + * Static factory methods and imports. + * Named parameters - can be simulated in Java using static factory methods. + +Real world example + +> We need to select numbers based on different criteria from the list. It's a great chance to +> utilize fluent interface pattern to provide readable easy-to-use developer experience. + +In plain words + +> Fluent Interface pattern provides easily readable flowing interface to code. + +Wikipedia says + +> In software engineering, a fluent interface is an object-oriented API whose design relies +> extensively on method chaining. Its goal is to increase code legibility by creating a +> domain-specific language (DSL). + +**Programmatic Example** + +In this example two implementations of a `FluentIterable` interface are given. + +```java +public interface FluentIterable extends Iterable { + + FluentIterable filter(Predicate predicate); + + Optional first(); + + FluentIterable first(int count); + + Optional last(); + + FluentIterable last(int count); + + FluentIterable map(Function function); + + List asList(); + + static List copyToList(Iterable iterable) { + var copy = new ArrayList(); + iterable.forEach(copy::add); + return copy; + } +} +``` + +The `SimpleFluentIterable` evaluates eagerly and would be too costly for real world applications. + +```java +public class SimpleFluentIterable implements FluentIterable { + ... +} +``` + +The `LazyFluentIterable` is evaluated on termination. + +```java +public class LazyFluentIterable implements FluentIterable { + ... +} +``` + +Their usage is demonstrated with a simple number list that is filtered, transformed and collected. The +result is printed afterwards. + +```java + var integerList = List.of(1, -61, 14, -22, 18, -87, 6, 64, -82, 26, -98, 97, 45, 23, 2, -68); + + prettyPrint("The initial list contains: ", integerList); + + var firstFiveNegatives = SimpleFluentIterable + .fromCopyOf(integerList) + .filter(negatives()) + .first(3) + .asList(); + prettyPrint("The first three negative values are: ", firstFiveNegatives); + + + var lastTwoPositives = SimpleFluentIterable + .fromCopyOf(integerList) + .filter(positives()) + .last(2) + .asList(); + prettyPrint("The last two positive values are: ", lastTwoPositives); + + SimpleFluentIterable + .fromCopyOf(integerList) + .filter(number -> number % 2 == 0) + .first() + .ifPresent(evenNumber -> LOGGER.info("The first even number is: {}", evenNumber)); + + + var transformedList = SimpleFluentIterable + .fromCopyOf(integerList) + .filter(negatives()) + .map(transformToString()) + .asList(); + prettyPrint("A string-mapped list of negative numbers contains: ", transformedList); + + + var lastTwoOfFirstFourStringMapped = LazyFluentIterable + .from(integerList) + .filter(positives()) + .first(4) + .last(2) + .map(number -> "String[" + valueOf(number) + "]") + .asList(); + prettyPrint("The lazy list contains the last two of the first four positive numbers " + + "mapped to Strings: ", lastTwoOfFirstFourStringMapped); + + LazyFluentIterable + .from(integerList) + .filter(negatives()) + .first(2) + .last() + .ifPresent(number -> LOGGER.info("Last amongst first two negatives: {}", number)); +``` + +Program output: + +```java +The initial list contains: 1, -61, 14, -22, 18, -87, 6, 64, -82, 26, -98, 97, 45, 23, 2, -68. +The first three negative values are: -61, -22, -87. +The last two positive values are: 23, 2. +The first even number is: 14 +A string-mapped list of negative numbers contains: String[-61], String[-22], String[-87], String[-82], String[-98], String[-68]. +The lazy list contains the last two of the first four positive numbers mapped to Strings: String[18], String[6]. +Last amongst first two negatives: -22 +``` + +### Class diagram + +![Fluent Interface](./etc/fluentinterface.png "Fluent Interface") + +### Applicability + +Use the Fluent Interface pattern when + +* You provide an API that would benefit from a DSL-like usage. +* You have objects that are difficult to configure or use. + +### Known uses + +* [Java 8 Stream API](http://www.oracle.com/technetwork/articles/java/ma14-java-se-8-streams-2177646.html) +* [Google Guava FluentIterable](https://github.com/google/guava/wiki/FunctionalExplained) +* [JOOQ](http://www.jooq.org/doc/3.0/manual/getting-started/use-cases/jooq-as-a-standalone-sql-builder/) +* [Mockito](http://mockito.org/) +* [Java Hamcrest](http://code.google.com/p/hamcrest/wiki/Tutorial) + +### Credits + +* [Fluent Interface - Martin Fowler](http://www.martinfowler.com/bliki/FluentInterface.html) +* [Evolutionary architecture and emergent design: Fluent interfaces - Neal Ford](http://www.ibm.com/developerworks/library/j-eaed14/) +* [Internal DSL](http://www.infoq.com/articles/internal-dsls-java) +* [Domain Specific Languages](https://www.amazon.com/gp/product/0321712943/ref=as_li_tl?ie=UTF8&tag=javadesignpat-20&camp=1789&creative=9325&linkCode=as2&creativeASIN=0321712943&linkId=ad8351d6f5be7d8b7ecdb650731f85df) + +## Flux +[⬆](#content) + + +--- +layout: pattern +title: Flux +folder: flux +permalink: /patterns/flux/ +categories: Structural +tags: + - Decoupling +--- + +### Intent +Flux eschews MVC in favor of a unidirectional data flow. When a +user interacts with a view, the view propagates an action through a central +dispatcher, to the various stores that hold the application's data and business +logic, which updates all of the views that are affected. + +### Class diagram +![alt text](./etc/flux.png "Flux") + +### Applicability +Use the Flux pattern when + +* you want to focus on creating explicit and understandable update paths for your application's data, which makes tracing changes during development simpler and makes bugs easier to track down and fix. + +### Credits + +* [Flux - Application architecture for building user interfaces](http://facebook.github.io/flux/) + + +## Flyweight +[⬆](#content) + + +--- +layout: pattern +title: Flyweight +folder: flyweight +permalink: /patterns/flyweight/ +categories: Structural +tags: + - Gang Of Four + - Performance +--- + +### Intent + +Use sharing to support large numbers of fine-grained objects efficiently. + +### Explanation + +Real world example + +> Alchemist's shop has shelves full of magic potions. Many of the potions are the same so there is +> no need to create new object for each of them. Instead one object instance can represent multiple +> shelf items so memory footprint remains small. + +In plain words + +> It is used to minimize memory usage or computational expenses by sharing as much as possible with +> similar objects. + +Wikipedia says + +> In computer programming, flyweight is a software design pattern. A flyweight is an object that +> minimizes memory use by sharing as much data as possible with other similar objects; it is a way +> to use objects in large numbers when a simple repeated representation would use an unacceptable +> amount of memory. + +**Programmatic example** + +Translating our alchemist shop example from above. First of all we have different potion types: + +```java +public interface Potion { + void drink(); +} + +public class HealingPotion implements Potion { + private static final Logger LOGGER = LoggerFactory.getLogger(HealingPotion.class); + @Override + public void drink() { + LOGGER.info("You feel healed. (Potion={})", System.identityHashCode(this)); + } +} + +public class HolyWaterPotion implements Potion { + private static final Logger LOGGER = LoggerFactory.getLogger(HolyWaterPotion.class); + @Override + public void drink() { + LOGGER.info("You feel blessed. (Potion={})", System.identityHashCode(this)); + } +} + +public class InvisibilityPotion implements Potion { + private static final Logger LOGGER = LoggerFactory.getLogger(InvisibilityPotion.class); + @Override + public void drink() { + LOGGER.info("You become invisible. (Potion={})", System.identityHashCode(this)); + } +} +``` + +Then the actual Flyweight class `PotionFactory`, which is the factory for creating potions. + +```java +public class PotionFactory { + + private final Map potions; + + public PotionFactory() { + potions = new EnumMap<>(PotionType.class); + } + + Potion createPotion(PotionType type) { + var potion = potions.get(type); + if (potion == null) { + switch (type) { + case HEALING: + potion = new HealingPotion(); + potions.put(type, potion); + break; + case HOLY_WATER: + potion = new HolyWaterPotion(); + potions.put(type, potion); + break; + case INVISIBILITY: + potion = new InvisibilityPotion(); + potions.put(type, potion); + break; + default: + break; + } + } + return potion; + } +} +``` + +And it can be used as below: + +```java +var factory = new PotionFactory(); +factory.createPotion(PotionType.INVISIBILITY).drink(); // You become invisible. (Potion=6566818) +factory.createPotion(PotionType.HEALING).drink(); // You feel healed. (Potion=648129364) +factory.createPotion(PotionType.INVISIBILITY).drink(); // You become invisible. (Potion=6566818) +factory.createPotion(PotionType.HOLY_WATER).drink(); // You feel blessed. (Potion=1104106489) +factory.createPotion(PotionType.HOLY_WATER).drink(); // You feel blessed. (Potion=1104106489) +factory.createPotion(PotionType.HEALING).drink(); // You feel healed. (Potion=648129364) +``` + +Program output: + +```java +You become invisible. (Potion=6566818) +You feel healed. (Potion=648129364) +You become invisible. (Potion=6566818) +You feel blessed. (Potion=1104106489) +You feel blessed. (Potion=1104106489) +You feel healed. (Potion=648129364) +``` + +### Class diagram + +![alt text](./etc/flyweight.urm.png "Flyweight pattern class diagram") + +### Applicability + +The Flyweight pattern's effectiveness depends heavily on how and where it's used. Apply the +Flyweight pattern when all of the following are true: + +* An application uses a large number of objects. +* Storage costs are high because of the sheer quantity of objects. +* Most object state can be made extrinsic. +* Many groups of objects may be replaced by relatively few shared objects once extrinsic state is +removed. +* The application doesn't depend on object identity. Since flyweight objects may be shared, identity +tests will return true for conceptually distinct objects. + +## Real world examples + +* [java.lang.Integer#valueOf(int)](http://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html#valueOf%28int%29) and similarly for Byte, Character and other wrapped types. + +### Credits + +* [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/gp/product/0201633612/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0201633612&linkCode=as2&tag=javadesignpat-20&linkId=675d49790ce11db99d90bde47f1aeb59) +* [Head First Design Patterns: A Brain-Friendly Guide](https://www.amazon.com/gp/product/0596007124/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596007124&linkCode=as2&tag=javadesignpat-20&linkId=6b8b6eea86021af6c8e3cd3fc382cb5b) + + +# Les patrons de conception implémentés en Java + +![Java CI with Maven](https://github.com/iluwatar/java-design-patterns/workflows/Java%20CI%20with%20Maven/badge.svg) +[![License MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://raw.githubusercontent.com/iluwatar/java-design-patterns/master/LICENSE.md) +[![Lines of Code](https://sonarcloud.io/api/project_badges/measure?project=iluwatar_java-design-patterns&metric=ncloc)](https://sonarcloud.io/dashboard?id=iluwatar_java-design-patterns) +[![Coverage](https://sonarcloud.io/api/project_badges/measure?project=iluwatar_java-design-patterns&metric=coverage)](https://sonarcloud.io/dashboard?id=iluwatar_java-design-patterns) +[![Join the chat at https://gitter.im/iluwatar/java-design-patterns](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/iluwatar/java-design-patterns?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) + +[![All Contributors](https://img.shields.io/badge/all_contributors-148-orange.svg?style=flat-square)](#contributors-) + + +# Introduction + +Le patron de conception est la meilleure formatalisation qu'un programmeur +peut utiliser pour résoudre un problème lors d'une conception d'une application/system. + +Le patron de conception (design pattern) est là pour accélérer le processus de +développement en fournissant des paradigmes éprouvés. + +La réutilisation de patron de conception aide à prévenir des problèmes subtiles mais +qui sont à l'origine de problèmes majeures, comme cette pratique augmente la lisibilitée +du code par les développeurs/architectes familiers avec l'utilisation de ces concepts. + +# Commencer + +Ce site présente des modèles de conception Java. Les solutions ont été développées par des +développeurs et architectes expérimentés de la communauté open source. Les modèles peuvent être parcourus par leurs descriptions de haut niveau ou en regardant leur code source. Les exemples de code source sont bien commentés et peuvent être considérés comme tutoriels de programmation sur la façon d'implémenter un modèle spécifique. Nous utilisons le plus technologies Java open source éprouvées au combat. + +Avant de plonger dans le matériau, vous devez vous familiariser avec divers +[Principes de conception de logiciels](https://java-design-patterns.com/principles/). + +Toutes les conceptions doivent être aussi simples que possible. Vous devriez commencer par KISS, YAGNI, +et faire la chose la plus simple qui pourrait éventuellement fonctionner principes. Complexité et +les modèles ne devraient être introduits que lorsqu'ils sont nécessaires pour +extensibilité. + +Une fois que vous êtes familiarisé avec ces concepts, vous pouvez commencer à explorer +[modèles de conception disponibles](https://java-design-patterns.com/patterns/) par tout +des approches suivantes + + - Recherchez un modèle spécifique par son nom. Vous n'en trouvez pas? Veuillez signaler un nouveau modèle [ici](https://github.com/iluwatar/java-design-patterns/issues). + - Utilisation de balises telles que `Performance`, `Gang of Four` ou `Data access`. + - Utilisation des catégories de modèles, `Créatif`, `Comportemental` et autres. + +J'espère que les solutions orientées objet présentées sur ce site vous seront utiles +dans vos architectures et ayez autant de plaisir à les apprendre que nous en avons eu à les développer. + +# Comment contribuer + +Si vous souhaitez contribuer au projet, vous trouverez les informations pertinentes dans +notre [wiki développeur](https://github.com/iluwatar/java-design-patterns/wiki). Nous aiderons +vous et répondez à vos questions dans le [Gitter chatroom](https://gitter.im/iluwatar/java-design-patterns). + +# Licence + +Ce projet est concédé sous les termes de la licence MIT. + +## Front Controller +[⬆](#content) + + +--- +layout: pattern +title: Front Controller +folder: front-controller +permalink: /patterns/front-controller/ +categories: Structural +tags: + - Decoupling +--- + +### Intent +Introduce a common handler for all requests for a web site. This +way we can encapsulate common functionality such as security, +internationalization, routing and logging in a single place. + +### Class diagram +![alt text](./etc/front-controller.png "Front Controller") + +### Applicability +Use the Front Controller pattern when + +* you want to encapsulate common request handling functionality in single place +* you want to implements dynamic request handling i.e. change routing without modifying code +* make web server configuration portable, you only need to register the handler web server specific way + +## Real world examples + +* [Apache Struts](https://struts.apache.org/) + +### Credits + +* [J2EE Design Patterns](https://www.amazon.com/gp/product/0596004273/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596004273&linkCode=as2&tag=javadesignpat-20&linkId=48d37c67fb3d845b802fa9b619ad8f31) +* [Presentation Tier Patterns](http://www.javagyan.com/tutorials/corej2eepatterns/presentation-tier-patterns) +* [Patterns of Enterprise Application Architecture](https://www.amazon.com/gp/product/0321127420/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0321127420&linkCode=as2&tag=javadesignpat-20&linkId=d9f7d37b032ca6e96253562d075fcc4a) +* [J2EE Design Patterns](https://www.amazon.com/gp/product/0596004273/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596004273&linkCode=as2&tag=javadesignpat-20&linkId=f27d2644fbe5026ea448791a8ad09c94) + +## Game Loop +[⬆](#content) + +--- +layout: pattern +title: Game Loop +folder: game-loop +permalink: /patterns/game-loop/ +categories: Behavioral +tags: + - Game programming +--- + +### Intent + +A game loop runs continuously during gameplay. Each turn of the loop, it processes user input +without blocking, updates the game state, and renders the game. It tracks the passage of time to +control the rate of gameplay. + +This pattern decouples progression of game time from user input and processor speed. + +### Applicability + +This pattern is used in every game engine. + +### Explanation + +Real world example + +> Game loop is the main process of all the game rendering threads. It's present in all modern games. +> It drives input process, internal status update, rendering, AI and all the other processes. + +In plain words + +> Game Loop pattern ensures that game time progresses in equal speed in all different hardware +> setups. + +Wikipedia says + +> The central component of any game, from a programming standpoint, is the game loop. The game loop +> allows the game to run smoothly regardless of a user's input, or lack thereof. + +**Programmatic Example** + +Let's start with something simple. Here's `Bullet` class. Bullets will move in our game. For +demonstration purposes it's enough that it has 1-dimensional position. + +```java +public class Bullet { + + private float position; + + public Bullet() { + position = 0.0f; + } + + public float getPosition() { + return position; + } + + public void setPosition(float position) { + this.position = position; + } +} +``` + +`GameController` is responsible for moving objects in the game, including the aforementioned bullet. + +```java +public class GameController { + + protected final Bullet bullet; + + public GameController() { + bullet = new Bullet(); + } + + public void moveBullet(float offset) { + var currentPosition = bullet.getPosition(); + bullet.setPosition(currentPosition + offset); + } + + public float getBulletPosition() { + return bullet.getPosition(); + } +} +``` + +Now we introduce the game loop. Or actually in this demo we have 3 different game loops. Let's see +the base class `GameLoop` first. + +```java +public enum GameStatus { + + RUNNING, STOPPED +} + +public abstract class GameLoop { + + protected final Logger logger = LoggerFactory.getLogger(this.getClass()); + + protected volatile GameStatus status; + + protected GameController controller; + + private Thread gameThread; + + public GameLoop() { + controller = new GameController(); + status = GameStatus.STOPPED; + } + + public void run() { + status = GameStatus.RUNNING; + gameThread = new Thread(this::processGameLoop); + gameThread.start(); + } + + public void stop() { + status = GameStatus.STOPPED; + } + + public boolean isGameRunning() { + return status == GameStatus.RUNNING; + } + + protected void processInput() { + try { + var lag = new Random().nextInt(200) + 50; + Thread.sleep(lag); + } catch (InterruptedException e) { + logger.error(e.getMessage()); + } + } + + protected void render() { + var position = controller.getBulletPosition(); + logger.info("Current bullet position: " + position); + } + + protected abstract void processGameLoop(); +} +``` + +Here's the first game loop implementation, `FrameBasedGameLoop`: + +```java +public class FrameBasedGameLoop extends GameLoop { + + @Override + protected void processGameLoop() { + while (isGameRunning()) { + processInput(); + update(); + render(); + } + } + + protected void update() { + controller.moveBullet(0.5f); + } +} +``` + +Finally, we show all the game loops in action. + +```java + try { + LOGGER.info("Start frame-based game loop:"); + var frameBasedGameLoop = new FrameBasedGameLoop(); + frameBasedGameLoop.run(); + Thread.sleep(GAME_LOOP_DURATION_TIME); + frameBasedGameLoop.stop(); + LOGGER.info("Stop frame-based game loop."); + + LOGGER.info("Start variable-step game loop:"); + var variableStepGameLoop = new VariableStepGameLoop(); + variableStepGameLoop.run(); + Thread.sleep(GAME_LOOP_DURATION_TIME); + variableStepGameLoop.stop(); + LOGGER.info("Stop variable-step game loop."); + + LOGGER.info("Start fixed-step game loop:"); + var fixedStepGameLoop = new FixedStepGameLoop(); + fixedStepGameLoop.run(); + Thread.sleep(GAME_LOOP_DURATION_TIME); + fixedStepGameLoop.stop(); + LOGGER.info("Stop variable-step game loop."); + + } catch (InterruptedException e) { + LOGGER.error(e.getMessage()); + } +``` + +Program output: + +```java +Start frame-based game loop: +Current bullet position: 0.5 +Current bullet position: 1.0 +Current bullet position: 1.5 +Current bullet position: 2.0 +Current bullet position: 2.5 +Current bullet position: 3.0 +Current bullet position: 3.5 +Current bullet position: 4.0 +Current bullet position: 4.5 +Current bullet position: 5.0 +Current bullet position: 5.5 +Current bullet position: 6.0 +Stop frame-based game loop. +Start variable-step game loop: +Current bullet position: 6.5 +Current bullet position: 0.038 +Current bullet position: 0.084 +Current bullet position: 0.145 +Current bullet position: 0.1805 +Current bullet position: 0.28 +Current bullet position: 0.32 +Current bullet position: 0.42549998 +Current bullet position: 0.52849996 +Current bullet position: 0.57799995 +Current bullet position: 0.63199997 +Current bullet position: 0.672 +Current bullet position: 0.778 +Current bullet position: 0.848 +Current bullet position: 0.8955 +Current bullet position: 0.9635 +Stop variable-step game loop. +Start fixed-step game loop: +Current bullet position: 0.0 +Current bullet position: 1.086 +Current bullet position: 0.059999995 +Current bullet position: 0.12999998 +Current bullet position: 0.24000004 +Current bullet position: 0.33999994 +Current bullet position: 0.36999992 +Current bullet position: 0.43999985 +Current bullet position: 0.5399998 +Current bullet position: 0.65999967 +Current bullet position: 0.68999964 +Current bullet position: 0.7299996 +Current bullet position: 0.79999954 +Current bullet position: 0.89999944 +Current bullet position: 0.98999935 +Stop variable-step game loop. +``` + +### Class diagram + +![alt text](./etc/game-loop.urm.png "Game Loop pattern class diagram") + +### Credits + +* [Game Programming Patterns - Game Loop](http://gameprogrammingpatterns.com/game-loop.html) +* [Game Programming Patterns](https://www.amazon.com/gp/product/0990582906/ref=as_li_qf_asin_il_tl?ie=UTF8&tag=javadesignpat-20&creative=9325&linkCode=as2&creativeASIN=0990582906&linkId=1289749a703b3fe0e24cd8d604d7c40b) +* [Game Engine Architecture, Third Edition](https://www.amazon.com/gp/product/1138035459/ref=as_li_qf_asin_il_tl?ie=UTF8&tag=javadesignpat-20&creative=9325&linkCode=as2&creativeASIN=1138035459&linkId=94502746617211bc40e0ef49d29333ac) + +## Guarded Suspension +[⬆](#content) + +--- +layout: pattern +title: Guarded Suspension +folder: guarded-suspension +permalink: /patterns/guarded-suspension/ +categories: Concurrency +tags: + - Decoupling +--- + +### Intent +Use Guarded suspension pattern to handle a situation when you want to execute a method on object which is not in a proper state. + +### Class diagram +![Guarded Suspension diagram](./etc/guarded-suspension.png) + +### Applicability +Use Guarded Suspension pattern when the developer knows that the method execution will be blocked for a finite period of time + +### Related patterns + +* Balking + + +## Half Sync/Half Async +[⬆](#content) + +--- +layout: pattern +title: Half-Sync/Half-Async +folder: half-sync-half-async +permalink: /patterns/half-sync-half-async/ +categories: Concurrency +tags: + - Performance +--- + +### Intent +The Half-Sync/Half-Async pattern decouples synchronous I/O from +asynchronous I/O in a system to simplify concurrent programming effort without +degrading execution efficiency. + +### Class diagram +![Half-Sync/Half-Async class diagram](./etc/half-sync-half-async.png) + +### Applicability +Use Half-Sync/Half-Async pattern when + +* a system possesses following characteristics: + * the system must perform tasks in response to external events that occur asynchronously, like hardware interrupts in OS + * it is inefficient to dedicate separate thread of control to perform synchronous I/O for each external source of event + * the higher level tasks in the system can be simplified significantly if I/O is performed synchronously. +* one or more tasks in a system must run in a single thread of control, while other tasks may benefit from multi-threading. + +## Real world examples + +* [BSD Unix networking subsystem](https://www.dre.vanderbilt.edu/~schmidt/PDF/PLoP-95.pdf) +* [Real Time CORBA](http://www.omg.org/news/meetings/workshops/presentations/realtime2001/4-3_Pyarali_thread-pool.pdf) +* [Android AsyncTask framework](http://developer.android.com/reference/android/os/AsyncTask.html) + +### Credits + +* [Douglas C. Schmidt and Charles D. Cranor - Half Sync/Half Async](https://www.dre.vanderbilt.edu/~schmidt/PDF/PLoP-95.pdf) +* [Pattern Oriented Software Architecture Volume 2: Patterns for Concurrent and Networked Objects](https://www.amazon.com/gp/product/0471606952/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0471606952&linkCode=as2&tag=javadesignpat-20&linkId=889e4af72dca8261129bf14935e0f8dc) + +## Hexagonal Architecture +[⬆](#content) + +--- +layout: pattern +title: Hexagonal Architecture +folder: hexagonal +permalink: /patterns/hexagonal/ +pumlformat: svg +categories: Architectural +tags: + - Decoupling +--- + +### Also known as + +* Ports and Adapters +* Clean Architecture +* Onion Architecture + +### Intent +Allow an application to equally be driven by users, programs, automated test or batch scripts, and to be developed and tested in isolation from its eventual run-time devices and databases. + +### Class diagram +![Hexagonal Architecture class diagram](./etc/hexagonal.png) + +### Applicability +Use Hexagonal Architecture pattern when + +* When the application needs to be independent of any frameworks +* When it is important that the application highly maintainable and fully testable + +### Tutorials + +* [Build Maintainable Systems With Hexagonal Architecture](http://java-design-patterns.com/blog/build-maintainable-systems-with-hexagonal-architecture/) + +## Real world examples + +* [Apache Isis](https://isis.apache.org/) builds generic UI and REST API directly from the underlying domain objects + +### Credits + +* [Alistair Cockburn - Hexagonal Architecture](http://alistair.cockburn.us/Hexagonal+architecture) + +## Intercepting Filter +[⬆](#content) + +--- +layout: pattern +title: Intercepting Filter +folder: intercepting-filter +permalink: /patterns/intercepting-filter/ +categories: Behavioral +tags: + - Decoupling +--- + +### Intent +Provide pluggable filters to conduct necessary pre-processing and +post-processing to requests from a client to a target + +### Class diagram +![alt text](./etc/intercepting-filter.png "Intercepting Filter") + +### Applicability +Use the Intercepting Filter pattern when + +* a system uses pre-processing or post-processing requests +* a system should do the authentication/ authorization/ logging or tracking of request and then pass the requests to corresponding handlers +* you want a modular approach to configuring pre-processing and post-processing schemes + +### Tutorials + +* [Introduction to Intercepting Filter Pattern in Java](https://www.baeldung.com/intercepting-filter-pattern-in-java) + +## Real world examples + +* [javax.servlet.FilterChain](https://tomcat.apache.org/tomcat-8.0-doc/servletapi/javax/servlet/FilterChain.html) and [javax.servlet.Filter](https://tomcat.apache.org/tomcat-8.0-doc/servletapi/javax/servlet/Filter.html) +* [Struts 2 - Interceptors](https://struts.apache.org/core-developers/interceptors.html) + +### Credits + +* [TutorialsPoint - Intercepting Filter](http://www.tutorialspoint.com/design_pattern/intercepting_filter_pattern.htm) + +## Interpreter +[⬆](#content) + +--- +layout: pattern +title: Interpreter +folder: interpreter +permalink: /patterns/interpreter/ +categories: Behavioral +tags: + - Gang of Four +--- + +### Intent +Given a language, define a representation for its grammar along +with an interpreter that uses the representation to interpret sentences in the +language. + +### Class diagram +![alt text](./etc/interpreter_1.png "Interpreter") + +### Applicability +Use the Interpreter pattern when there is a language to +interpret, and you can represent statements in the language as abstract syntax +trees. The Interpreter pattern works best when + +* the grammar is simple. For complex grammars, the class hierarchy for the grammar becomes large and unmanageable. Tools such as parser generators are a better alternative in such cases. They can interpret expressions without building abstract syntax trees, which can save space and possibly time +* efficiency is not a critical concern. The most efficient interpreters are usually not implemented by interpreting parse trees directly but by first translating them into another form. For example, regular expressions are often transformed into state machines. But even then, the translator can be implemented by the Interpreter pattern, so the pattern is still applicable + +## Real world examples + +* [java.util.Pattern](http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html) +* [java.text.Normalizer](http://docs.oracle.com/javase/8/docs/api/java/text/Normalizer.html) +* All subclasses of [java.text.Format](http://docs.oracle.com/javase/8/docs/api/java/text/Format.html) +* [javax.el.ELResolver](http://docs.oracle.com/javaee/7/api/javax/el/ELResolver.html) + + +### Credits + +* [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/gp/product/0201633612/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0201633612&linkCode=as2&tag=javadesignpat-20&linkId=675d49790ce11db99d90bde47f1aeb59) +* [Head First Design Patterns: A Brain-Friendly Guide](https://www.amazon.com/gp/product/0596007124/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596007124&linkCode=as2&tag=javadesignpat-20&linkId=6b8b6eea86021af6c8e3cd3fc382cb5b) +* [Refactoring to Patterns](https://www.amazon.com/gp/product/0321213351/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0321213351&linkCode=as2&tag=javadesignpat-20&linkId=2a76fcb387234bc71b1c61150b3cc3a7) + +## Iterator +[⬆](#content) + +--- +layout: pattern +title: Iterator +folder: iterator +permalink: /patterns/iterator/ +categories: Behavioral +tags: + - Gang of Four +--- + +### Also known as + +Cursor + +### Intent +Provide a way to access the elements of an aggregate object sequentially without exposing its +underlying representation. + +### Explanation + +Real world example + +> Treasure chest contains a set of magical items. There multiple types of items such as rings, +> potions and weapons. The items can be browsed by type using an iterator the treasure chest +> provides. + +In plain words + +> Containers can provide a representation agnostic iterator interface to provide access to the +> elements. + +Wikipedia says + +> In object-oriented programming, the iterator pattern is a design pattern in which an iterator is +> used to traverse a container and access the container's elements. + +**Programmatic Example** + +The main class in our example is the `TreasureChest` that contains items. + +```java +public class TreasureChest { + + private final List items; + + public TreasureChest() { + items = List.of( + new Item(ItemType.POTION, "Potion of courage"), + new Item(ItemType.RING, "Ring of shadows"), + new Item(ItemType.POTION, "Potion of wisdom"), + new Item(ItemType.POTION, "Potion of blood"), + new Item(ItemType.WEAPON, "Sword of silver +1"), + new Item(ItemType.POTION, "Potion of rust"), + new Item(ItemType.POTION, "Potion of healing"), + new Item(ItemType.RING, "Ring of armor"), + new Item(ItemType.WEAPON, "Steel halberd"), + new Item(ItemType.WEAPON, "Dagger of poison")); + } + + public Iterator iterator(ItemType itemType) { + return new TreasureChestItemIterator(this, itemType); + } + + public List getItems() { + return new ArrayList<>(items); + } +} +``` + +Here's the `Item` class: + +```java +public class Item { + + private ItemType type; + private final String name; + + public Item(ItemType type, String name) { + this.setType(type); + this.name = name; + } + + @Override + public String toString() { + return name; + } + + public ItemType getType() { + return type; + } + + public final void setType(ItemType type) { + this.type = type; + } +} + +public enum ItemType { + + ANY, WEAPON, RING, POTION + +} +``` + +The `Iterator` interface is extremely simple. + +```java +public interface Iterator { + + boolean hasNext(); + + T next(); +} +``` + +In the following example we iterate through the ring type items found in the chest. + +```java +var itemIterator = TREASURE_CHEST.iterator(ItemType.RING); +while (itemIterator.hasNext()) { + LOGGER.info(itemIterator.next().toString()); +} +``` + +Program output: + +```java +Ring of shadows +Ring of armor +``` + +### Class diagram + +![alt text](./etc/iterator_1.png "Iterator") + +### Applicability + +Use the Iterator pattern + +* To access an aggregate object's contents without exposing its internal representation. +* To support multiple traversals of aggregate objects. +* To provide a uniform interface for traversing different aggregate structures. + +### Tutorials + +* [How to Use Iterator?](http://www.tutorialspoint.com/java/java_using_iterator.htm) + +## Real world examples + +* [java.util.Iterator](http://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html) +* [java.util.Enumeration](http://docs.oracle.com/javase/8/docs/api/java/util/Enumeration.html) + +### Credits + +* [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/gp/product/0201633612/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0201633612&linkCode=as2&tag=javadesignpat-20&linkId=675d49790ce11db99d90bde47f1aeb59) +* [Head First Design Patterns: A Brain-Friendly Guide](https://www.amazon.com/gp/product/0596007124/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596007124&linkCode=as2&tag=javadesignpat-20&linkId=6b8b6eea86021af6c8e3cd3fc382cb5b) + + +# 자바로 구현된 디자인 패턴 + +![Java CI with Maven](https://github.com/iluwatar/java-design-patterns/workflows/Java%20CI%20with%20Maven/badge.svg)[](https://raw.githubusercontent.com/iluwatar/java-design-patterns/master/LICENSE.md)![License MIT](https://img.shields.io/badge/license-MIT-blue.svg)[](https://sonarcloud.io/dashboard?id=iluwatar_java-design-patterns)![Join the chat at https://gitter.im/iluwatar/java-design-patterns](https://badges.gitter.im/Join%20Chat.svg) + + +## Layers +[⬆](#content) + +--- +layout: pattern +title: Layers +folder: layers +permalink: /patterns/layers/ +pumlformat: svg +categories: Architectural +tags: + - Decoupling +--- + +### Intent + +Layers is an architectural pattern where software responsibilities are divided among the different +layers of the application. + +### Explanation + +Real world example + +> Consider a web site displaying decorated cakes for weddings and such. Instead of the web page +> directly reaching into the database, it relies on a service to deliver this information. The +> service then queries the data layer to assimilate the needed information. + +In plain words + +> With Layers architectural pattern different concerns reside on separate layers. View layer is +> interested only in rendering, service layer assembles the requested data from various sources, and +> data layer gets the bits from the data storage. + +Wikipedia says + +> In software engineering, multitier architecture (often referred to as n-tier architecture) or +> multilayered architecture is a client–server architecture in which presentation, application +> processing, and data management functions are physically separated. + +**Programmatic Example** + +On the data layer, we keep our cake building blocks. `Cake` consist of layers and topping. + +```java +@Entity +public class Cake { + + @Id + @GeneratedValue + private Long id; + + @OneToOne(cascade = CascadeType.REMOVE) + private CakeTopping topping; + + @OneToMany(cascade = CascadeType.REMOVE, fetch = FetchType.EAGER) + private Set layers; +} +``` + +The service layer offers `CakeBakingService` for easy access to different aspects of cakes. + +```java +public interface CakeBakingService { + + void bakeNewCake(CakeInfo cakeInfo) throws CakeBakingException; + + List getAllCakes(); + + void saveNewTopping(CakeToppingInfo toppingInfo); + + List getAvailableToppings(); + + void saveNewLayer(CakeLayerInfo layerInfo); + + List getAvailableLayers(); +} +``` + +On the top we have our `View` responsible of rendering the cakes. + +```java +public interface View { + + void render(); + +} + +public class CakeViewImpl implements View { + + private static final Logger LOGGER = LoggerFactory.getLogger(CakeViewImpl.class); + + private final CakeBakingService cakeBakingService; + + public CakeViewImpl(CakeBakingService cakeBakingService) { + this.cakeBakingService = cakeBakingService; + } + + public void render() { + cakeBakingService.getAllCakes().forEach(cake -> LOGGER.info(cake.toString())); + } +} +``` + +### Class diagram + +![alt text](./etc/layers.png "Layers") + +### Applicability + +Use the Layers architecture when + +* You want clearly divide software responsibilities into different parts of the program. +* You want to prevent a change from propagating throughout the application. +* You want to make your application more maintainable and testable. + +### Credits + +* [Pattern Oriented Software Architecture Volume 1: A System of Patterns](https://www.amazon.com/gp/product/0471958697/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0471958697&linkCode=as2&tag=javadesignpat-20&linkId=e3f42d7a2a4cc8c619bbc0136b20dadb) + +## Lazy Loading +[⬆](#content) + +--- +layout: pattern +title: Lazy Loading +folder: lazy-loading +permalink: /patterns/lazy-loading/ +categories: Idiom +tags: + - Performance +--- + +### Intent +Lazy loading is a design pattern commonly used to defer +initialization of an object until the point at which it is needed. It can +contribute to efficiency in the program's operation if properly and +appropriately used. + +### Class diagram +![alt text](./etc/lazy-loading.png "Lazy Loading") + +### Applicability +Use the Lazy Loading idiom when + +* eager loading is expensive or the object to be loaded might not be needed at all + +## Real world examples + +* JPA annotations @OneToOne, @OneToMany, @ManyToOne, @ManyToMany and fetch = FetchType.LAZY + +### Credits + +* [J2EE Design Patterns](https://www.amazon.com/gp/product/0596004273/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596004273&linkCode=as2&tag=javadesignpat-20&linkId=48d37c67fb3d845b802fa9b619ad8f31) +* [Patterns of Enterprise Application Architecture](https://www.amazon.com/gp/product/0321127420/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0321127420&linkCode=as2&tag=javadesignpat-20&linkId=d9f7d37b032ca6e96253562d075fcc4a) + +## Leader Election +[⬆](#content) + +--- +layout: pattern +title: Leader Election +folder: leader-election +permalink: /patterns/leader-election/ +categories: Behavioral +tags: + - Cloud distributed +--- + +### Intent +Leader Election pattern is commonly used in cloud system design. It can help to ensure that task instances select the leader instance correctly and do not conflict with each other, cause contention for shared resources, or inadvertently interfere with the work that other task instances are performing. + +### Class diagram +![alt text](./etc/leader-election.urm.png "Leader Election pattern class diagram") + +### Applicability +Use this pattern when + +* the tasks in a distributed application, such as a cloud-hosted solution, require careful coordination and there is no natural leader. + +Do not use this pattern when + +* there is a natural leader or dedicated process that can always act as the leader. For example, it may be possible to implement a singleton process that coordinates the task instances. If this process fails or becomes unhealthy, the system can shut it down and restart it. +* the coordination between tasks can be easily achieved by using a more lightweight mechanism. For example, if several task instances simply require coordinated access to a shared resource, a preferable solution might be to use optimistic or pessimistic locking to control access to that resource. + +## Real world examples + +* [Raft Leader Election](https://github.com/ronenhamias/raft-leader-election) + +### Credits + +* [Leader Election pattern](https://docs.microsoft.com/en-us/azure/architecture/patterns/leader-election) + +## Leader Followers +[⬆](#content) + +--- +layout: pattern +title: Leader/Followers +folder: leader-followers +permalink: /patterns/leader-followers/ +categories: Concurrency +tags: + - Performance +--- + +### Intent +The Leader/Followers pattern provides a concurrency model where multiple +threads can efficiently de-multiplex events and dispatch event handlers +that process I/O handles shared by the threads. + +### Class diagram +![Leader/Followers class diagram](./etc/leader-followers.png) + +### Applicability +Use Leader-Followers pattern when + +* multiple threads take turns sharing a set of event sources in order to detect, de-multiplex, dispatch and process service requests that occur on the event sources. + +## Real world examples + +* [ACE Thread Pool Reactor framework](https://www.dre.vanderbilt.edu/~schmidt/PDF/HPL.pdf) +* [JAWS](http://www.dre.vanderbilt.edu/~schmidt/PDF/PDCP.pdf) +* [Real-time CORBA](http://www.dre.vanderbilt.edu/~schmidt/PDF/RTS.pdf) + +### Credits + +* [Douglas C. Schmidt and Carlos O’Ryan - Leader/Followers](http://www.kircher-schwanninger.de/michael/publications/lf.pdf) + +## Marker Interface +[⬆](#content) + +--- +layout: pattern +title: Marker Interface +folder: marker +permalink: /patterns/marker/ +categories: Structural +tags: + - Decoupling +--- + +### Intent +Using empty interfaces as markers to distinguish special treated objects. + +### Class diagram +![alt text](./etc/MarkerDiagram.png "Marker Interface") + +### Applicability +Use the Marker Interface pattern when + +* you want to identify the special objects from normal objects (to treat them differently) +* you want to mark that some object is available for certain sort of operations + +## Real world examples + +* [javase.8.docs.api.java.io.Serializable](https://docs.oracle.com/javase/8/docs/api/java/io/Serializable.html) +* [javase.8.docs.api.java.lang.Cloneable](https://docs.oracle.com/javase/8/docs/api/java/lang/Cloneable.html) + +### Credits + +* [Effective Java](https://www.amazon.com/gp/product/0134685997/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0134685997&linkCode=as2&tag=javadesignpat-20&linkId=4e349f4b3ff8c50123f8147c828e53eb) + +## Master Worker +[⬆](#content) + +--- +layout: pattern +title: Master-Worker +folder: master-worker-pattern +permalink: /patterns/master-worker-pattern/ +categories: Concurrency +tags: + - Performance +--- + +### Also known as + +> Master-slave or Map-reduce + +### Intent + +> Used for centralised parallel processing. + +### Class diagram +![alt text](./etc/master-worker-pattern.urm.png "Master-Worker pattern class diagram") + +### Applicability +This pattern can be used when data can be divided into multiple parts, all of which need to go through the same computation to give a result, which need to be aggregated to get the final result. + +### Explanation +In this pattern, parallel processing is performed using a system consisting of a master and some number of workers, where a master divides the work among the workers, gets the result back from them and assimilates all the results to give final result. The only communication is between the master and the worker - none of the workers communicate among one another and the user only communicates with the master to get the required job done. The master has to maintain a record of how the divided data has been distributed, how many workers have finished their work and returned a result, and the results themselves to be able to aggregate the data correctly. + +### Credits + +* [https://docs.gigaspaces.com/sbp/master-worker-pattern.html] +* [http://www.cs.sjsu.edu/~pearce/oom/patterns/behavioral/masterslave.htm] + +## Mediator +[⬆](#content) + +--- +layout: pattern +title: Mediator +folder: mediator +permalink: /patterns/mediator/ +categories: Behavioral +tags: + - Gang Of Four + - Decoupling +--- + +### Intent +Define an object that encapsulates how a set of objects interact. +Mediator promotes loose coupling by keeping objects from referring to each +other explicitly, and it lets you vary their interaction independently. + +### Class diagram +![alt text](./etc/mediator_1.png "Mediator") + +### Applicability +Use the Mediator pattern when + +* a set of objects communicate in well-defined but complex ways. The resulting interdependencies are unstructured and difficult to understand +* reusing an object is difficult because it refers to and communicates with many other objects +* a behavior that's distributed between several classes should be customizable without a lot of subclassing + +## Real world examples + +* All scheduleXXX() methods of [java.util.Timer](http://docs.oracle.com/javase/8/docs/api/java/util/Timer.html) +* [java.util.concurrent.Executor#execute()](http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Executor.html#execute-java.lang.Runnable-) +* submit() and invokeXXX() methods of [java.util.concurrent.ExecutorService](http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ExecutorService.html) +* scheduleXXX() methods of [java.util.concurrent.ScheduledExecutorService](http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ScheduledExecutorService.html) +* [java.lang.reflect.Method#invoke()](http://docs.oracle.com/javase/8/docs/api/java/lang/reflect/Method.html#invoke-java.lang.Object-java.lang.Object...-) + +### Credits + +* [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/gp/product/0201633612/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0201633612&linkCode=as2&tag=javadesignpat-20&linkId=675d49790ce11db99d90bde47f1aeb59) +* [Head First Design Patterns: A Brain-Friendly Guide](https://www.amazon.com/gp/product/0596007124/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596007124&linkCode=as2&tag=javadesignpat-20&linkId=6b8b6eea86021af6c8e3cd3fc382cb5b) + +## Memento +[⬆](#content) + +--- +layout: pattern +title: Memento +folder: memento +permalink: /patterns/memento/ +categories: Behavioral +tags: + - Gang of Four +--- + +### Also known as + +Token + +### Intent + +Without violating encapsulation, capture and externalize an object's internal state so that the +object can be restored to this state later. + +### Explanation + +Real world example + +> We are working on astrology application where we need to analyze star properties over time. We are +> creating snapshots of star state using Memento pattern. + +In plain words + +> Memento pattern captures object internal state making it easy to store and restore objects in any +> point of time. + +Wikipedia says + +> The memento pattern is a software design pattern that provides the ability to restore an object to +> its previous state (undo via rollback). + +**Programmatic Example** + +Let's first define the types of stars we are capable to handle. + +```java +public enum StarType { + SUN("sun"), + RED_GIANT("red giant"), + WHITE_DWARF("white dwarf"), + SUPERNOVA("supernova"), + DEAD("dead star"); + ... +} +``` + +Next, let's jump straight to the essentials. Here's the `Star` class along with the mementos that we +need manipulate. Especially pay attention to `getMemento` and `setMemento` methods. + +```java +public interface StarMemento { +} + +public class Star { + + private StarType type; + private int ageYears; + private int massTons; + + public Star(StarType startType, int startAge, int startMass) { + this.type = startType; + this.ageYears = startAge; + this.massTons = startMass; + } + + public void timePasses() { + ageYears *= 2; + massTons *= 8; + switch (type) { + case RED_GIANT: + type = StarType.WHITE_DWARF; + break; + case SUN: + type = StarType.RED_GIANT; + break; + case SUPERNOVA: + type = StarType.DEAD; + break; + case WHITE_DWARF: + type = StarType.SUPERNOVA; + break; + case DEAD: + ageYears *= 2; + massTons = 0; + break; + default: + break; + } + } + + StarMemento getMemento() { + var state = new StarMementoInternal(); + state.setAgeYears(ageYears); + state.setMassTons(massTons); + state.setType(type); + return state; + } + + void setMemento(StarMemento memento) { + var state = (StarMementoInternal) memento; + this.type = state.getType(); + this.ageYears = state.getAgeYears(); + this.massTons = state.getMassTons(); + } + + @Override + public String toString() { + return String.format("%s age: %d years mass: %d tons", type.toString(), ageYears, massTons); + } + + private static class StarMementoInternal implements StarMemento { + + private StarType type; + private int ageYears; + private int massTons; + + // setters and getters -> + ... + } +} +``` + +And finally here's how we use the mementos to store and restore star states. + +```java + var states = new Stack<>(); + var star = new Star(StarType.SUN, 10000000, 500000); + LOGGER.info(star.toString()); + states.add(star.getMemento()); + star.timePasses(); + LOGGER.info(star.toString()); + states.add(star.getMemento()); + star.timePasses(); + LOGGER.info(star.toString()); + states.add(star.getMemento()); + star.timePasses(); + LOGGER.info(star.toString()); + states.add(star.getMemento()); + star.timePasses(); + LOGGER.info(star.toString()); + while (states.size() > 0) { + star.setMemento(states.pop()); + LOGGER.info(star.toString()); + } +``` + +Program output: + +``` +sun age: 10000000 years mass: 500000 tons +red giant age: 20000000 years mass: 4000000 tons +white dwarf age: 40000000 years mass: 32000000 tons +supernova age: 80000000 years mass: 256000000 tons +dead star age: 160000000 years mass: 2048000000 tons +supernova age: 80000000 years mass: 256000000 tons +white dwarf age: 40000000 years mass: 32000000 tons +red giant age: 20000000 years mass: 4000000 tons +sun age: 10000000 years mass: 500000 tons +``` + +### Class diagram + +![alt text](./etc/memento.png "Memento") + +### Applicability + +Use the Memento pattern when + +* A snapshot of an object's state must be saved so that it can be restored to that state later, and +* A direct interface to obtaining the state would expose implementation details and break the +object's encapsulation + +## Real world examples + +* [java.util.Date](http://docs.oracle.com/javase/8/docs/api/java/util/Date.html) + +### Credits + +* [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/gp/product/0201633612/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0201633612&linkCode=as2&tag=javadesignpat-20&linkId=675d49790ce11db99d90bde47f1aeb59) +* [Head First Design Patterns: A Brain-Friendly Guide](https://www.amazon.com/gp/product/0596007124/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596007124&linkCode=as2&tag=javadesignpat-20&linkId=6b8b6eea86021af6c8e3cd3fc382cb5b) + + +## Model View Controller +[⬆](#content) + +--- +layout: pattern +title: Model-View-Controller +folder: model-view-controller +permalink: /patterns/model-view-controller/ +categories: Architectural +tags: + - Decoupling +--- + +### Intent +Separate the user interface into three interconnected components: +the model, the view and the controller. Let the model manage the data, the view +display the data and the controller mediate updating the data and redrawing the +display. + +### Class diagram +![alt text](./etc/model-view-controller.png "Model-View-Controller") + +### Applicability +Use the Model-View-Controller pattern when + +* You want to clearly separate the domain data from its user interface representation + +### Credits + +* [Trygve Reenskaug - Model-view-controller](http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller) +* [J2EE Design Patterns](https://www.amazon.com/gp/product/0596004273/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596004273&linkCode=as2&tag=javadesignpat-20&linkId=48d37c67fb3d845b802fa9b619ad8f31) +* [Patterns of Enterprise Application Architecture](https://www.amazon.com/gp/product/0321127420/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0321127420&linkCode=as2&tag=javadesignpat-20&linkId=d9f7d37b032ca6e96253562d075fcc4a) +* [Head First Design Patterns: A Brain-Friendly Guide](https://www.amazon.com/gp/product/0596007124/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596007124&linkCode=as2&tag=javadesignpat-20&linkId=6b8b6eea86021af6c8e3cd3fc382cb5b) +* [J2EE Design Patterns](https://www.amazon.com/gp/product/0596004273/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596004273&linkCode=as2&tag=javadesignpat-20&linkId=f27d2644fbe5026ea448791a8ad09c94) + +## Model View Presenter +[⬆](#content) + +--- +layout: pattern +title: Model-View-Presenter +folder: model-view-presenter +permalink: /patterns/model-view-presenter/ +categories: Architectural +tags: + - Decoupling +--- + +### Intent +Apply a "Separation of Concerns" principle in a way that allows +developers to build and test user interfaces. + +### Class diagram +![alt text](./etc/model-view-presenter_1.png "Model-View-Presenter") + +### Applicability +Use the Model-View-Presenter in any of the following +situations + +* When you want to improve the "Separation of Concerns" principle in presentation logic +* When a user interface development and testing is necessary. + +## Real world examples + +* [MVP4J](https://github.com/amineoualialami/mvp4j) + +## Module +[⬆](#content) + +--- +layout: pattern +title: Module +folder: module +permalink: /patterns/module/ +categories: Structural +tags: + - Decoupling +--- + +### Intent +Module pattern is used to implement the concept of software modules, defined by modular programming, in a programming language with incomplete direct support for the concept. + +### Class diagram +![alt text](./etc/module.png "Module") + +### Applicability +The Module pattern can be considered a creational pattern and a structural pattern. It manages the creation and organization of other elements, and groups them as the structural pattern does. + +An object that applies this pattern can provide the equivalent of a namespace, providing the initialization and finalization process of a static class or a class with static members with cleaner, more concise syntax and semantics. + +### Credits + +* [Module](https://en.wikipedia.org/wiki/Module_pattern) + +## Monad +[⬆](#content) + +--- +layout: pattern +title: Monad +folder: monad +permalink: /patterns/monad/ +categories: Functional +tags: + - Reactive +--- + +### Intent + +Monad pattern based on monad from linear algebra represents the way of chaining operations +together step by step. Binding functions can be described as passing one's output to another's input +basing on the 'same type' contract. Formally, monad consists of a type constructor M and two +operations: +bind - that takes monadic object and a function from plain object to monadic value and returns monadic value +return - that takes plain type object and returns this object wrapped in a monadic value. + +### Class diagram +![alt text](./etc/monad.png "Monad") + +### Applicability + +Use the Monad in any of the following situations + +* When you want to chain operations easily +* When you want to apply each function regardless of the result of any of them + +### Credits + +* [Design Pattern Reloaded by Remi Forax](https://youtu.be/-k2X7guaArU) +* [Brian Beckman: Don't fear the Monad](https://channel9.msdn.com/Shows/Going+Deep/Brian-Beckman-Dont-fear-the-Monads) +* [Monad on Wikipedia](https://en.wikipedia.org/wiki/Monad_(functional_programming)) + +## Monostate +[⬆](#content) + +--- +layout: pattern +title: MonoState +folder: monostate +permalink: /patterns/monostate/ +categories: Creational +tags: + - Instantiation +--- + +### Also known as +Borg + +### Intent +Enforces a behaviour like sharing the same state amongst all instances. + +### Class diagram +![alt text](./etc/monostate.png "MonoState") + +### Applicability +Use the Monostate pattern when + +* The same state must be shared across all instances of a class. +* Typically this pattern might be used everywhere a Singleton might be used. Singleton usage however is not transparent, Monostate usage is. +* Monostate has one major advantage over singleton. The subclasses might decorate the shared state as they wish and hence can provide dynamically different behaviour than the base class. + +## Typical Use Case + +* The logging class +* Managing a connection to a database +* File manager + +## Real world examples + +Yet to see this. + +## Multiton +[⬆](#content) + +--- +layout: pattern +title: Multiton +folder: multiton +permalink: /patterns/multiton/ +categories: Creational +tags: + - Instantiation +--- + +### Also known as + +Registry + +### Intent + +Ensure a class only has limited number of instances and provide a global point of access to them. + +### Explanation + +Real world example + +> The Nazgûl, also called ringwraiths or the Nine Riders, are Sauron's most terrible servants. By +> definition there's always nine of them. + +In plain words + +> Multiton pattern ensures there's predefined amount of instances available globally. + +Wikipedia says + +> In software engineering, the multiton pattern is a design pattern which generalizes the singleton +> pattern. Whereas the singleton allows only one instance of a class to be created, the multiton +> pattern allows for the controlled creation of multiple instances, which it manages through the use +> of a map. + +**Programmatic Example** + +`Nazgul` is the multiton class. + +```java +public enum NazgulName { + + KHAMUL, MURAZOR, DWAR, JI_INDUR, AKHORAHIL, HOARMURATH, ADUNAPHEL, REN, UVATHA +} + +public final class Nazgul { + + private static final Map nazguls; + + private final NazgulName name; + + static { + nazguls = new ConcurrentHashMap<>(); + nazguls.put(NazgulName.KHAMUL, new Nazgul(NazgulName.KHAMUL)); + nazguls.put(NazgulName.MURAZOR, new Nazgul(NazgulName.MURAZOR)); + nazguls.put(NazgulName.DWAR, new Nazgul(NazgulName.DWAR)); + nazguls.put(NazgulName.JI_INDUR, new Nazgul(NazgulName.JI_INDUR)); + nazguls.put(NazgulName.AKHORAHIL, new Nazgul(NazgulName.AKHORAHIL)); + nazguls.put(NazgulName.HOARMURATH, new Nazgul(NazgulName.HOARMURATH)); + nazguls.put(NazgulName.ADUNAPHEL, new Nazgul(NazgulName.ADUNAPHEL)); + nazguls.put(NazgulName.REN, new Nazgul(NazgulName.REN)); + nazguls.put(NazgulName.UVATHA, new Nazgul(NazgulName.UVATHA)); + } + + private Nazgul(NazgulName name) { + this.name = name; + } + + public static Nazgul getInstance(NazgulName name) { + return nazguls.get(name); + } + + public NazgulName getName() { + return name; + } +} +``` + +And here's how we access the `Nazgul` instances. + +```java + LOGGER.info("KHAMUL={}", Nazgul.getInstance(NazgulName.KHAMUL)); + LOGGER.info("MURAZOR={}", Nazgul.getInstance(NazgulName.MURAZOR)); + LOGGER.info("DWAR={}", Nazgul.getInstance(NazgulName.DWAR)); + LOGGER.info("JI_INDUR={}", Nazgul.getInstance(NazgulName.JI_INDUR)); + LOGGER.info("AKHORAHIL={}", Nazgul.getInstance(NazgulName.AKHORAHIL)); + LOGGER.info("HOARMURATH={}", Nazgul.getInstance(NazgulName.HOARMURATH)); + LOGGER.info("ADUNAPHEL={}", Nazgul.getInstance(NazgulName.ADUNAPHEL)); + LOGGER.info("REN={}", Nazgul.getInstance(NazgulName.REN)); + LOGGER.info("UVATHA={}", Nazgul.getInstance(NazgulName.UVATHA)); +``` + +Program output: + +``` +KHAMUL=com.iluwatar.multiton.Nazgul@2b214b94 +MURAZOR=com.iluwatar.multiton.Nazgul@17814b1c +DWAR=com.iluwatar.multiton.Nazgul@7ac9af2a +JI_INDUR=com.iluwatar.multiton.Nazgul@7bb004b8 +AKHORAHIL=com.iluwatar.multiton.Nazgul@78e89bfe +HOARMURATH=com.iluwatar.multiton.Nazgul@652ce654 +ADUNAPHEL=com.iluwatar.multiton.Nazgul@522ba524 +REN=com.iluwatar.multiton.Nazgul@29c5ee1d +UVATHA=com.iluwatar.multiton.Nazgul@15cea7b0 +``` + +### Class diagram + +![alt text](./etc/multiton.png "Multiton") + +### Applicability + +Use the Multiton pattern when + +* There must be specific number of instances of a class, and they must be accessible to clients from +a well-known access point. + +## Mute Idiom +[⬆](#content) + +--- +layout: pattern +title: Mute Idiom +folder: mute-idiom +permalink: /patterns/mute-idiom/ +categories: Idiom +tags: + - Decoupling +--- + +### Intent +Provide a template to suppress any exceptions that either are declared but cannot occur or should only be logged; +while executing some business logic. The template removes the need to write repeated `try-catch` blocks. + +### Class diagram +![alt text](./etc/mute-idiom.png "Mute Idiom") + +### Applicability +Use this idiom when + +* an API declares some exception but can never throw that exception eg. ByteArrayOutputStream bulk write method. +* you need to suppress some exception just by logging it, such as closing a resource. + +### Credits + +* [JOOQ: Mute Design Pattern](http://blog.jooq.org/2016/02/18/the-mute-design-pattern/) + +## Naked Objects +[⬆](#content) + +--- +layout: pattern +title: Naked Objects +folder: naked-objects +permalink: /patterns/naked-objects/ +categories: Architectural +tags: + - Decoupling +--- + +### Intent +The Naked Objects architectural pattern is well suited for rapid +prototyping. Using the pattern, you only need to write the domain objects, +everything else is autogenerated by the framework. + +### Class diagram +![alt text](./etc/naked-objects.png "Naked Objects") + +### Applicability +Use the Naked Objects pattern when + +* You are prototyping and need fast development cycle +* An autogenerated user interface is good enough +* You want to automatically publish the domain as REST services + +## Real world examples + +* [Apache Isis](https://isis.apache.org/) + +### Credits + +* [Richard Pawson - Naked Objects](http://downloads.nakedobjects.net/resources/Pawson%20thesis.pdf) + +## Null Object +[⬆](#content) + +--- +layout: pattern +title: Null Object +folder: null-object +permalink: /patterns/null-object/ +categories: Behavioral +tags: + - Extensibility +--- + +### Intent + +In most object-oriented languages, such as Java or C#, references may be null. These references need +to be checked to ensure they are not null before invoking any methods, because methods typically +cannot be invoked on null references. Instead of using a null reference to convey absence of an +object (for instance, a non-existent customer), one uses an object which implements the expected +interface, but whose method body is empty. The advantage of this approach over a working default +implementation is that a Null Object is very predictable and has no side effects: it does nothing. + +### Explanation + +Real world example + +> We are building a binary tree from nodes. There are ordinary nodes and "empty" nodes. Traversing +> the tree normally should not cause errors, so we use null object pattern where necessary. + +In plain words + +> Null Object pattern handles "empty" objects gracefully. + +Wikipedia says + +> In object-oriented computer programming, a null object is an object with no referenced value or +> with defined neutral ("null") behavior. The null object design pattern describes the uses of such +> objects and their behavior (or lack thereof). + +**Programmatic Example** + +Here's the definition of `Node` interface. + +```java +public interface Node { + + String getName(); + + int getTreeSize(); + + Node getLeft(); + + Node getRight(); + + void walk(); +} +``` + +We have two implementations of `Node`. The normal implementation `NodeImpl` and `NullNode` for +empty nodes. + +```java +public class NodeImpl implements Node { + + private static final Logger LOGGER = LoggerFactory.getLogger(NodeImpl.class); + + private final String name; + private final Node left; + private final Node right; + + /** + * Constructor. + */ + public NodeImpl(String name, Node left, Node right) { + this.name = name; + this.left = left; + this.right = right; + } + + @Override + public int getTreeSize() { + return 1 + left.getTreeSize() + right.getTreeSize(); + } + + @Override + public Node getLeft() { + return left; + } + + @Override + public Node getRight() { + return right; + } + + @Override + public String getName() { + return name; + } + + @Override + public void walk() { + LOGGER.info(name); + if (left.getTreeSize() > 0) { + left.walk(); + } + if (right.getTreeSize() > 0) { + right.walk(); + } + } +} + +public final class NullNode implements Node { + + private static final NullNode instance = new NullNode(); + + private NullNode() { + } + + public static NullNode getInstance() { + return instance; + } + + @Override + public int getTreeSize() { + return 0; + } + + @Override + public Node getLeft() { + return null; + } + + @Override + public Node getRight() { + return null; + } + + @Override + public String getName() { + return null; + } + + @Override + public void walk() { + // Do nothing + } +} +``` + +Then we can construct and traverse the binary tree without errors as follows. + +```java + var root = new NodeImpl("1", + new NodeImpl("11", + new NodeImpl("111", NullNode.getInstance(), NullNode.getInstance()), + NullNode.getInstance() + ), + new NodeImpl("12", + NullNode.getInstance(), + new NodeImpl("122", NullNode.getInstance(), NullNode.getInstance()) + ) + ); + root.walk(); +``` + +Program output: + +``` +1 +11 +111 +12 +122 +``` + +### Class diagram + +![alt text](./etc/null-object.png "Null Object") + +### Applicability + +Use the Null Object pattern when + +* You want to avoid explicit null checks and keep the algorithm elegant and easy to read. + +### Credits + +* [Pattern Languages of Program Design 3](https://www.amazon.com/gp/product/0201310112/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0201310112&linkCode=as2&tag=javadesignpat-20&linkId=7372ffb8a4e39a3bb10f199b89aef921) +* [Refactoring to Patterns](https://www.amazon.com/gp/product/0321213351/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0321213351&linkCode=as2&tag=javadesignpat-20&linkId=2a76fcb387234bc71b1c61150b3cc3a7) + +## Object Mother +[⬆](#content) + +--- +layout: pattern +title: Object Mother +folder: object-mother +permalink: /patterns/object-mother/ +categories: Creational +tags: + - Instantiation +--- + +## Object Mother +Define a factory of immutable content with separated builder and factory interfaces. + +### Class diagram +![alt text](./etc/object-mother.png "Object Mother") + +### Applicability +Use the Object Mother pattern when + +* You want consistent objects over several tests +* You want to reduce code for creation of objects in tests +* Every test should run with fresh data + +### Credits + +* [Answer by David Brown](http://stackoverflow.com/questions/923319/what-is-an-objectmother) to the stackoverflow question: [What is an ObjectMother?](http://stackoverflow.com/questions/923319/what-is-an-objectmother) +* [c2wiki - Object Mother](http://c2.com/cgi/wiki?ObjectMother) +* [Nat Pryce - Test Data Builders: an alternative to the Object Mother pattern](http://www.natpryce.com/articles/000714.html) + +## Object Pool +[⬆](#content) + +--- +layout: pattern +title: Object Pool +folder: object-pool +permalink: /patterns/object-pool/ +categories: Creational +tags: + - Game programming + - Performance +--- + +### Also known as + +Resource Pool + +### Intent + +When objects are expensive to create and they are needed only for short periods of time it is +advantageous to utilize the Object Pool pattern. The Object Pool provides a cache for instantiated +objects tracking which ones are in use and which are available. + +### Explanation + +Real world example + +> In our war game we need to use oliphaunts, massive and mythic beasts, but the problem is that they +> are extremely expensive to create. The solution is to create a pool of them, track which ones are +> in-use, and instead of disposing them re-use the instances. + +In plain words + +> Object Pool manages a set of instances instead of creating and destroying them on demand. + +Wikipedia says + +> The object pool pattern is a software creational design pattern that uses a set of initialized +> objects kept ready to use – a "pool" – rather than allocating and destroying them on demand. + +**Programmatic Example** + +Here's the basic `Oliphaunt` class. These giants are very expensive to create. + +```java +public class Oliphaunt { + + private static final AtomicInteger counter = new AtomicInteger(0); + + private final int id; + + public Oliphaunt() { + id = counter.incrementAndGet(); + try { + Thread.sleep(1000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + + public int getId() { + return id; + } + + @Override + public String toString() { + return String.format("Oliphaunt id=%d", id); + } +} +``` + +Next we present the `ObjectPool` and more specifically `OliphauntPool`. + +```java +public abstract class ObjectPool { + + private final Set available = new HashSet<>(); + private final Set inUse = new HashSet<>(); + + protected abstract T create(); + + public synchronized T checkOut() { + if (available.isEmpty()) { + available.add(create()); + } + var instance = available.iterator().next(); + available.remove(instance); + inUse.add(instance); + return instance; + } + + public synchronized void checkIn(T instance) { + inUse.remove(instance); + available.add(instance); + } + + @Override + public synchronized String toString() { + return String.format("Pool available=%d inUse=%d", available.size(), inUse.size()); + } +} + +public class OliphauntPool extends ObjectPool { + + @Override + protected Oliphaunt create() { + return new Oliphaunt(); + } +} +``` + +Finally, here's how we utilize the pool. + +```java + var pool = new OliphauntPool(); + var oliphaunt1 = pool.checkOut(); + var oliphaunt2 = pool.checkOut(); + var oliphaunt3 = pool.checkOut(); + pool.checkIn(oliphaunt1); + pool.checkIn(oliphaunt2); + var oliphaunt4 = pool.checkOut(); + var oliphaunt5 = pool.checkOut(); +``` + +Program output: + +``` +Pool available=0 inUse=0 +Checked out Oliphaunt id=1 +Pool available=0 inUse=1 +Checked out Oliphaunt id=2 +Checked out Oliphaunt id=3 +Pool available=0 inUse=3 +Checking in Oliphaunt id=1 +Checking in Oliphaunt id=2 +Pool available=2 inUse=1 +Checked out Oliphaunt id=2 +Checked out Oliphaunt id=1 +Pool available=0 inUse=3 +``` + +### Class diagram + +![alt text](./etc/object-pool.png "Object Pool") + +### Applicability + +Use the Object Pool pattern when + +* The objects are expensive to create (allocation cost). +* You need a large number of short-lived objects (memory fragmentation). + +## Observer +[⬆](#content) + +--- +layout: pattern +title: Observer +folder: observer +permalink: /patterns/observer/ +categories: Behavioral +tags: + - Gang Of Four + - Reactive +--- + +### Also known as + +Dependents, Publish-Subscribe + +### Intent + +Define a one-to-many dependency between objects so that when one object changes state, all its +dependents are notified and updated automatically. + +### Explanation + +Real world example + +> In a land far away lives the races of hobbits and orcs. Both of them are mostly outdoors so they +> closely follow the changes in weather. One could say that they are constantly observing the +> weather. + +In plain words + +> Register as an observer to receive state changes in the object. + +Wikipedia says + +> The observer pattern is a software design pattern in which an object, called the subject, +> maintains a list of its dependents, called observers, and notifies them automatically of any state +> changes, usually by calling one of their methods. + +**Programmatic Example** + +Let's first introduce the `WeatherObserver` interface and our races, `Orcs` and `Hobbits`. + +```java +public interface WeatherObserver { + + void update(WeatherType currentWeather); +} + +public class Orcs implements WeatherObserver { + + private static final Logger LOGGER = LoggerFactory.getLogger(Orcs.class); + + @Override + public void update(WeatherType currentWeather) { + LOGGER.info("The orcs are facing " + currentWeather.getDescription() + " weather now"); + } +} + +public class Hobbits implements WeatherObserver { + + private static final Logger LOGGER = LoggerFactory.getLogger(Hobbits.class); + + @Override + public void update(WeatherType currentWeather) { + switch (currentWeather) { + LOGGER.info("The hobbits are facing " + currentWeather.getDescription() + " weather now"); + } + } +} +``` + +Then here's the `Weather` that is constantly changing. + +```java +public class Weather { + + private static final Logger LOGGER = LoggerFactory.getLogger(Weather.class); + + private WeatherType currentWeather; + private final List observers; + + public Weather() { + observers = new ArrayList<>(); + currentWeather = WeatherType.SUNNY; + } + + public void addObserver(WeatherObserver obs) { + observers.add(obs); + } + + public void removeObserver(WeatherObserver obs) { + observers.remove(obs); + } + + /** + * Makes time pass for weather. + */ + public void timePasses() { + var enumValues = WeatherType.values(); + currentWeather = enumValues[(currentWeather.ordinal() + 1) % enumValues.length]; + LOGGER.info("The weather changed to {}.", currentWeather); + notifyObservers(); + } + + private void notifyObservers() { + for (var obs : observers) { + obs.update(currentWeather); + } + } +} +``` + +Here's the full example in action. + +```java + var weather = new Weather(); + weather.addObserver(new Orcs()); + weather.addObserver(new Hobbits()); + weather.timePasses(); + weather.timePasses(); + weather.timePasses(); + weather.timePasses(); +``` + +Program output: + +``` +The weather changed to rainy. +The orcs are facing rainy weather now +The hobbits are facing rainy weather now +The weather changed to windy. +The orcs are facing windy weather now +The hobbits are facing windy weather now +The weather changed to cold. +The orcs are facing cold weather now +The hobbits are facing cold weather now +The weather changed to sunny. +The orcs are facing sunny weather now +The hobbits are facing sunny weather now +``` + +### Class diagram + +![alt text](./etc/observer.png "Observer") + +### Applicability + +Use the Observer pattern in any of the following situations: + +* When an abstraction has two aspects, one dependent on the other. Encapsulating these aspects in +separate objects lets you vary and reuse them independently. +* When a change to one object requires changing others, and you don't know how many objects need to +be changed. +* When an object should be able to notify other objects without making assumptions about who these +objects are. In other words, you don't want these objects tightly coupled. + +## Typical Use Case + +* Changing in one object leads to a change in other objects. + +## Real world examples + +* [java.util.Observer](http://docs.oracle.com/javase/8/docs/api/java/util/Observer.html) +* [java.util.EventListener](http://docs.oracle.com/javase/8/docs/api/java/util/EventListener.html) +* [javax.servlet.http.HttpSessionBindingListener](http://docs.oracle.com/javaee/7/api/javax/servlet/http/HttpSessionBindingListener.html) +* [RxJava](https://github.com/ReactiveX/RxJava) + +### Credits + +* [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/gp/product/0201633612/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0201633612&linkCode=as2&tag=javadesignpat-20&linkId=675d49790ce11db99d90bde47f1aeb59) +* [Java Generics and Collections](https://www.amazon.com/gp/product/0596527756/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596527756&linkCode=as2&tag=javadesignpat-20&linkId=246e5e2c26fe1c3ada6a70b15afcb195) +* [Head First Design Patterns: A Brain-Friendly Guide](https://www.amazon.com/gp/product/0596007124/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596007124&linkCode=as2&tag=javadesignpat-20&linkId=6b8b6eea86021af6c8e3cd3fc382cb5b) +* [Refactoring to Patterns](https://www.amazon.com/gp/product/0321213351/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0321213351&linkCode=as2&tag=javadesignpat-20&linkId=2a76fcb387234bc71b1c61150b3cc3a7) + +## Page Object +[⬆](#content) + +--- +layout: pattern +title: Page Object +folder: page-object +permalink: /patterns/page-object/ +categories: Structural +tags: +- Decoupling +--- + +### Intent + +Page Object encapsulates the UI, hiding the underlying UI widgetry of an application (commonly a web application) and providing an application-specific API to allow the manipulation of UI components required for tests. In doing so, it allows the test class itself to focus on the test logic instead. + +### Class diagram +![alt text](./etc/page-object.png "Page Object") + + +### Applicability + +Use the Page Object pattern when + +* You are writing automated tests for your web application and you want to separate the UI manipulation required for the tests from the actual test logic. +* Make your tests less brittle, and more readable and robust + +### Credits + +* [Martin Fowler - PageObject](http://martinfowler.com/bliki/PageObject.html) +* [Selenium - Page Objects](https://github.com/SeleniumHQ/selenium/wiki/PageObjects) + +## Partial Response +[⬆](#content) + +--- +layout: pattern +title: Partial Response +folder: partial-response +permalink: /patterns/partial-response/ +categories: Behavioral +tags: + - Decoupling +--- + +### Intent +Send partial response from server to client on need basis. Client will specify the the fields +that it need to server, instead of serving all details for resource. + +### Class diagram +![alt text](./etc/partial-response.urm.png "partial-response") + +### Applicability +Use the Partial Response pattern when + +* Client need only subset of data from resource. +* To avoid too much data transfer over wire + +### Credits + +* [Common Design Patterns](https://cloud.google.com/apis/design/design_patterns) + +## Pipeline +[⬆](#content) + +--- +layout: pattern +title: Pipeline +folder: pipeline +permalink: /patterns/pipeline/ +categories: Behavioral +tags: + - Decoupling +--- + +### Intent + +Allows processing of data in a series of stages by giving in an initial input and passing the +processed output to be used by the next stages. + +### Explanation + +The Pipeline pattern uses ordered stages to process a sequence of input values. Each implemented +task is represented by a stage of the pipeline. You can think of pipelines as similar to assembly +lines in a factory, where each item in the assembly line is constructed in stages. The partially +assembled item is passed from one assembly stage to another. The outputs of the assembly line occur +in the same order as that of the inputs. + +Real world example + +> Suppose we wanted to pass through a string to a series of filtering stages and convert it as a +> char array on the last stage. + +In plain words + +> Pipeline pattern is an assembly line where partial results are passed from one stage to another. + +Wikipedia says + +> In software engineering, a pipeline consists of a chain of processing elements (processes, +> threads, coroutines, functions, etc.), arranged so that the output of each element is the input +> of the next; the name is by analogy to a physical pipeline. + +**Programmatic Example** + +The stages of our pipeline are called `Handler`s. + +```java +interface Handler { + O process(I input); +} +``` + +In our string processing example we have 3 different concrete `Handler`s. + +```java +class RemoveAlphabetsHandler implements Handler { + ... +} + +class RemoveDigitsHandler implements Handler { + ... +} + +class ConvertToCharArrayHandler implements Handler { + ... +} +``` + +Here is the `Pipeline` that will gather and execute the handlers one by one. + +```java +class Pipeline { + + private final Handler currentHandler; + + Pipeline(Handler currentHandler) { + this.currentHandler = currentHandler; + } + + Pipeline addHandler(Handler newHandler) { + return new Pipeline<>(input -> newHandler.process(currentHandler.process(input))); + } + + O execute(I input) { + return currentHandler.process(input); + } +} +``` + +And here's the `Pipeline` in action processing the string. + +```java + var filters = new Pipeline<>(new RemoveAlphabetsHandler()) + .addHandler(new RemoveDigitsHandler()) + .addHandler(new ConvertToCharArrayHandler()); + filters.execute("GoYankees123!"); +``` + +### Class diagram + +![alt text](./etc/pipeline.urm.png "Pipeline pattern class diagram") + +### Applicability + +Use the Pipeline pattern when you want to + +* Execute individual stages that yields a final value. +* Add readability to complex sequence of operations by providing a fluent builder as an interface. +* Improve testability of code since stages will most likely be doing a single thing, complying to +the [Single Responsibility Principle (SRP)](https://java-design-patterns.com/principles/#single-responsibility-principle) + +### Known uses + +* [java.util.Stream](https://docs.oracle.com/javase/8/docs/api/java/util/stream/package-summary.html) +* [Maven Build Lifecycle](http://maven.apache.org/guides/introduction/introduction-to-the-lifecycle.html) +* [Functional Java](https://github.com/functionaljava/functionaljava) + +### Related patterns + +* [Chain of Responsibility](https://java-design-patterns.com/patterns/chain/) + +### Credits + +* [The Pipeline Pattern — for fun and profit](https://medium.com/@aaronweatherall/the-pipeline-pattern-for-fun-and-profit-9b5f43a98130) +* [The Pipeline design pattern (in Java)](https://medium.com/@deepakbapat/the-pipeline-design-pattern-in-java-831d9ce2fe21) +* [Pipelines | Microsoft Docs](https://docs.microsoft.com/en-us/previous-versions/msp-n-p/ff963548(v=pandp.10)) + +## Poison Pill +[⬆](#content) + +--- +layout: pattern +title: Poison Pill +folder: poison-pill +permalink: /patterns/poison-pill/ +categories: Behavioral +tags: + - Cloud distributed + - Reactive +--- + +### Intent + +Poison Pill is known predefined data item that allows to provide graceful shutdown for separate +distributed consumption process. + +### Explanation + +Real world example + +> Let's think about a message queue with one producer and one consumer. The producer keeps pushing +> new messages in the queue and the consumer keeps reading them. Finally when it's time to +> gracefully shut down the producer sends the poison pill message. + +In plain words + +> Poison Pill is a known message structure that ends the message exchange. + +**Programmatic Example** + +Let's define the message structure first. There's interface `Message` and implementation +`SimpleMessage`. + +```java +public interface Message { + + ... + + enum Headers { + DATE, SENDER + } + + void addHeader(Headers header, String value); + + String getHeader(Headers header); + + Map getHeaders(); + + void setBody(String body); + + String getBody(); +} + +public class SimpleMessage implements Message { + + private final Map headers = new HashMap<>(); + private String body; + + @Override + public void addHeader(Headers header, String value) { + headers.put(header, value); + } + + @Override + public String getHeader(Headers header) { + return headers.get(header); + } + + @Override + public Map getHeaders() { + return Collections.unmodifiableMap(headers); + } + + @Override + public void setBody(String body) { + this.body = body; + } + + @Override + public String getBody() { + return body; + } +} +``` + +To pass messages we are using message queues. Here we define the types related to the message queue: +`MqPublishPoint`, `MqSubscribePoint` and `MessageQueue`. `SimpleMessageQueue` implements all these +interfaces. + +```java +public interface MqPublishPoint { + + void put(Message msg) throws InterruptedException; +} + +public interface MqSubscribePoint { + + Message take() throws InterruptedException; +} + +public interface MessageQueue extends MqPublishPoint, MqSubscribePoint { +} + +public class SimpleMessageQueue implements MessageQueue { + + private final BlockingQueue queue; + + public SimpleMessageQueue(int bound) { + queue = new ArrayBlockingQueue<>(bound); + } + + @Override + public void put(Message msg) throws InterruptedException { + queue.put(msg); + } + + @Override + public Message take() throws InterruptedException { + return queue.take(); + } +} +``` + +Next we need message `Producer` and `Consumer`. Internally they use the message queues from above. +It's important to notice that when `Producer` stops, it sends out the poison pill to inform +`Consumer` that the messaging has finished. + +```java +public class Producer { + + ... + + public void send(String body) { + if (isStopped) { + throw new IllegalStateException(String.format( + "Producer %s was stopped and fail to deliver requested message [%s].", body, name)); + } + var msg = new SimpleMessage(); + msg.addHeader(Headers.DATE, new Date().toString()); + msg.addHeader(Headers.SENDER, name); + msg.setBody(body); + + try { + queue.put(msg); + } catch (InterruptedException e) { + // allow thread to exit + LOGGER.error("Exception caught.", e); + } + } + + public void stop() { + isStopped = true; + try { + queue.put(Message.POISON_PILL); + } catch (InterruptedException e) { + // allow thread to exit + LOGGER.error("Exception caught.", e); + } + } +} + +public class Consumer { + + ... + + public void consume() { + while (true) { + try { + var msg = queue.take(); + if (Message.POISON_PILL.equals(msg)) { + LOGGER.info("Consumer {} receive request to terminate.", name); + break; + } + var sender = msg.getHeader(Headers.SENDER); + var body = msg.getBody(); + LOGGER.info("Message [{}] from [{}] received by [{}]", body, sender, name); + } catch (InterruptedException e) { + // allow thread to exit + LOGGER.error("Exception caught.", e); + return; + } + } + } +} +``` + +Finally we are ready to present the whole example in action. + +```java + var queue = new SimpleMessageQueue(10000); + + final var producer = new Producer("PRODUCER_1", queue); + final var consumer = new Consumer("CONSUMER_1", queue); + + new Thread(consumer::consume).start(); + + new Thread(() -> { + producer.send("hand shake"); + producer.send("some very important information"); + producer.send("bye!"); + producer.stop(); + }).start(); +``` + +Program output: + +``` +Message [hand shake] from [PRODUCER_1] received by [CONSUMER_1] +Message [some very important information] from [PRODUCER_1] received by [CONSUMER_1] +Message [bye!] from [PRODUCER_1] received by [CONSUMER_1] +Consumer CONSUMER_1 receive request to terminate. +``` + +### Class diagram + +![alt text](./etc/poison-pill.png "Poison Pill") + +### Applicability + +Use the Poison Pill idiom when: + +* There's a need to send signal from one thread/process to another to terminate. + +## Real world examples + +* [akka.actor.PoisonPill](http://doc.akka.io/docs/akka/2.1.4/java/untyped-actors.html) + +## Priority Queue Pattern +[⬆](#content) + +--- +layout: pattern +title: Priority Queue Pattern +folder: priority-queue +permalink: /patterns/priority-queue/ +categories: Behavioral +tags: + - Decoupling + - Cloud distributed +--- + +### Intent + +Prioritize requests sent to services so that requests with a higher priority are received and +processed more quickly than those of a lower priority. This pattern is useful in applications that +offer different service level guarantees to individual clients. + +### Explanation + +Applications may delegate specific tasks to other services; for example, to perform background +processing or to integrate with other applications or services. In the cloud, a message queue is +typically used to delegate tasks to background processing. In many cases the order in which requests +are received by a service is not important. However, in some cases it may be necessary to prioritize +specific requests. These requests should be processed earlier than others of a lower priority that +may have been sent previously by the application. + +Real world example + +> Imagine a video processing service with free and premium customers. The requests coming from the +> paying premium customers should be prioritized over the others. + +In plain words + +> Priority Queue enables processing of high priority messages first, regardless of queue size or +> message age. + +Wikipedia says + +> In computer science, a priority queue is an abstract data type similar to regular queue or stack +> data structure in which each element additionally has a "priority" associated with it. In a +> priority queue, an element with high priority is served before an element with low priority. + +**Programmatic Example** + +Looking at the video processing example from above, let's first see the `Message` structure. + +```java +public class Message implements Comparable { + + private final String message; + private final int priority; // define message priority in queue + + public Message(String message, int priority) { + this.message = message; + this.priority = priority; + } + + @Override + public int compareTo(Message o) { + return priority - o.priority; + } + ... +} +``` + +Here's `PriorityMessageQueue` that handles storing the messages and serving them in priority +order. + +```java +public class PriorityMessageQueue { + + ... + + public T remove() { + if (isEmpty()) { + return null; + } + + final var root = queue[0]; + queue[0] = queue[size - 1]; + size--; + maxHeapifyDown(); + return root; + } + + public void add(T t) { + ensureCapacity(); + queue[size] = t; + size++; + maxHeapifyUp(); + } + + ... +} +``` + +`QueueManager` has a `PriorityMessageQueue` and makes it easy to `publishMessage` and +`receiveMessage`. + +```java +public class QueueManager { + + private final PriorityMessageQueue messagePriorityMessageQueue; + + public QueueManager(int initialCapacity) { + messagePriorityMessageQueue = new PriorityMessageQueue<>(new Message[initialCapacity]); + } + + public void publishMessage(Message message) { + messagePriorityMessageQueue.add(message); + } + + public Message receiveMessage() { + if (messagePriorityMessageQueue.isEmpty()) { + return null; + } + return messagePriorityMessageQueue.remove(); + } +} +``` + +`Worker` constantly polls `QueueManager` for highest priority message and processes it. + +```java +public class Worker { + + private static final Logger LOGGER = LoggerFactory.getLogger(Worker.class); + + private final QueueManager queueManager; + + public Worker(QueueManager queueManager) { + this.queueManager = queueManager; + } + + public void run() throws Exception { + while (true) { + var message = queueManager.receiveMessage(); + if (message == null) { + LOGGER.info("No Message ... waiting"); + Thread.sleep(200); + } else { + processMessage(message); + } + } + } + + private void processMessage(Message message) { + LOGGER.info(message.toString()); + } +} +``` + +Here's the full example how we create an instance of `QueueManager` and process messages using +`Worker`. + +```java + var queueManager = new QueueManager(100); + + for (var i = 0; i < 100; i++) { + queueManager.publishMessage(new Message("Low Message Priority", 0)); + } + + for (var i = 0; i < 100; i++) { + queueManager.publishMessage(new Message("High Message Priority", 1)); + } + + var worker = new Worker(queueManager); + worker.run(); +``` + +Program output: + +``` +Message{message='High Message Priority', priority=1} +Message{message='High Message Priority', priority=1} +Message{message='High Message Priority', priority=1} +Message{message='High Message Priority', priority=1} +Message{message='High Message Priority', priority=1} +Message{message='High Message Priority', priority=1} +Message{message='High Message Priority', priority=1} +Message{message='High Message Priority', priority=1} +Message{message='High Message Priority', priority=1} +Message{message='High Message Priority', priority=1} +Message{message='Low Message Priority', priority=0} +Message{message='Low Message Priority', priority=0} +Message{message='Low Message Priority', priority=0} +Message{message='Low Message Priority', priority=0} +Message{message='Low Message Priority', priority=0} +Message{message='Low Message Priority', priority=0} +Message{message='Low Message Priority', priority=0} +Message{message='Low Message Priority', priority=0} +Message{message='Low Message Priority', priority=0} +Message{message='Low Message Priority', priority=0} +No Message ... waiting +No Message ... waiting +No Message ... waiting +``` + + +### Class diagram + +![alt text](./etc/priority-queue.urm.png "Priority Queue pattern class diagram") + +### Applicability + +Use the Priority Queue pattern when: + +* The system must handle multiple tasks that might have different priorities. +* Different users or tenants should be served with different priority. + +### Credits + +* [Priority Queue pattern](https://docs.microsoft.com/en-us/azure/architecture/patterns/priority-queue) + +## Private Class Data +[⬆](#content) + +--- +layout: pattern +title: Private Class Data +folder: private-class-data +permalink: /patterns/private-class-data/ +categories: Idiom +tags: + - Data access +--- + +### Intent + +Private Class Data design pattern seeks to reduce exposure of attributes by limiting their +visibility. It reduces the number of class attributes by encapsulating them in single Data object. + +### Explanation + +Real world example + +> Imagine you are cooking a stew for your family for dinner. You want to prevent your family members +> from consuming the stew by tasting it while you are cooking, otherwise there will be no more stew +> for dinner later. + +In plain words + +> Private class data pattern prevents manipulation of data that is meant to be immutable by +> separating the data from the methods that use it into a class that maintains the data state. + +Wikipedia says + +> Private class data is a design pattern in computer programming used to encapsulate class +> attributes and their manipulation. + +**Programmatic Example** + +Taking our stew example from above. First we have a `Stew` class where its data is not protected by +private class data, making the stew's ingredient mutable to class methods. + +```java +public class Stew { + private static final Logger LOGGER = LoggerFactory.getLogger(Stew.class); + private int numPotatoes; + private int numCarrots; + private int numMeat; + private int numPeppers; + public Stew(int numPotatoes, int numCarrots, int numMeat, int numPeppers) { + this.numPotatoes = numPotatoes; + this.numCarrots = numCarrots; + this.numMeat = numMeat; + this.numPeppers = numPeppers; + } + public void mix() { + LOGGER.info("Mixing the stew we find: {} potatoes, {} carrots, {} meat and {} peppers", + numPotatoes, numCarrots, numMeat, numPeppers); + } + public void taste() { + LOGGER.info("Tasting the stew"); + if (numPotatoes > 0) { + numPotatoes--; + } + if (numCarrots > 0) { + numCarrots--; + } + if (numMeat > 0) { + numMeat--; + } + if (numPeppers > 0) { + numPeppers--; + } + } +} +``` + +Now, we have `ImmutableStew` class, where its data is protected by `StewData` class. Now, the +methods in are unable to manipulate the data of the `ImmutableStew` class. + +```java +public class StewData { + private final int numPotatoes; + private final int numCarrots; + private final int numMeat; + private final int numPeppers; + public StewData(int numPotatoes, int numCarrots, int numMeat, int numPeppers) { + this.numPotatoes = numPotatoes; + this.numCarrots = numCarrots; + this.numMeat = numMeat; + this.numPeppers = numPeppers; + } + public int getNumPotatoes() { + return numPotatoes; + } + public int getNumCarrots() { + return numCarrots; + } + public int getNumMeat() { + return numMeat; + } + public int getNumPeppers() { + return numPeppers; + } +} +public class ImmutableStew { + private static final Logger LOGGER = LoggerFactory.getLogger(ImmutableStew.class); + private final StewData data; + public ImmutableStew(int numPotatoes, int numCarrots, int numMeat, int numPeppers) { + data = new StewData(numPotatoes, numCarrots, numMeat, numPeppers); + } + public void mix() { + LOGGER + .info("Mixing the immutable stew we find: {} potatoes, {} carrots, {} meat and {} peppers", + data.getNumPotatoes(), data.getNumCarrots(), data.getNumMeat(), data.getNumPeppers()); + } +} +``` + +Let's try creating an instance of each class and call their methods: + +```java +var stew = new Stew(1, 2, 3, 4); +stew.mix(); // Mixing the stew we find: 1 potatoes, 2 carrots, 3 meat and 4 peppers +stew.taste(); // Tasting the stew +stew.mix(); // Mixing the stew we find: 0 potatoes, 1 carrots, 2 meat and 3 peppers +var immutableStew = new ImmutableStew(2, 4, 3, 6); +immutableStew.mix(); // Mixing the immutable stew we find: 2 potatoes, 4 carrots, 3 meat and 6 peppers +``` + +### Class diagram + +![alt text](./etc/private-class-data.png "Private Class Data") + +### Applicability + +Use the Private Class Data pattern when + +* You want to prevent write access to class data members. + +## Producer Consumer +[⬆](#content) + +--- +layout: pattern +title: Producer Consumer +folder: producer-consumer +permalink: /patterns/producer-consumer/ +categories: Concurrency +tags: + - Reactive +--- + +### Intent +Producer Consumer Design pattern is a classic concurrency pattern which reduces + coupling between Producer and Consumer by separating Identification of work with Execution of + Work. + +### Class diagram +![alt text](./etc/producer-consumer.png "Producer Consumer") + +### Applicability +Use the Producer Consumer idiom when + +* Decouple system by separate work in two process produce and consume. +* Addresses the issue of different timing require to produce work or consuming work + +## Promise +[⬆](#content) + +--- +layout: pattern +title: Promise +folder: promise +permalink: /patterns/promise/ +categories: Concurrency +tags: + - Reactive +--- + +### Also known as + +CompletableFuture + +### Intent + +A Promise represents a proxy for a value not necessarily known when the promise is created. It +allows you to associate dependent promises to an asynchronous action's eventual success value or +failure reason. Promises are a way to write async code that still appears as though it is executing +in a synchronous way. + +### Explanation + +The Promise object is used for asynchronous computations. A Promise represents an operation that +hasn't completed yet, but is expected in the future. + +Promises provide a few advantages over callback objects: + * Functional composition and error handling. + * Prevents callback hell and provides callback aggregation. + +Real world example + +> We are developing a software solution that downloads files and calculates the number of lines and +> character frequencies in those files. Promise is an ideal solution to make the code concise and +> easy to understand. + +In plain words + +> Promise is a placeholder for an asynchronous operation that is ongoing. + +Wikipedia says + +> In computer science, future, promise, delay, and deferred refer to constructs used for +> synchronizing program execution in some concurrent programming languages. They describe an object +> that acts as a proxy for a result that is initially unknown, usually because the computation of +> its value is not yet complete. + +**Programmatic Example** + +In the example a file is downloaded and its line count is calculated. The calculated line count is +then consumed and printed on console. + +Let's first introduce a support class we need for implementation. Here's `PromiseSupport`. + +```java +class PromiseSupport implements Future { + + private static final Logger LOGGER = LoggerFactory.getLogger(PromiseSupport.class); + + private static final int RUNNING = 1; + private static final int FAILED = 2; + private static final int COMPLETED = 3; + + private final Object lock; + + private volatile int state = RUNNING; + private T value; + private Exception exception; + + PromiseSupport() { + this.lock = new Object(); + } + + void fulfill(T value) { + this.value = value; + this.state = COMPLETED; + synchronized (lock) { + lock.notifyAll(); + } + } + + void fulfillExceptionally(Exception exception) { + this.exception = exception; + this.state = FAILED; + synchronized (lock) { + lock.notifyAll(); + } + } + + @Override + public boolean cancel(boolean mayInterruptIfRunning) { + return false; + } + + @Override + public boolean isCancelled() { + return false; + } + + @Override + public boolean isDone() { + return state > RUNNING; + } + + @Override + public T get() throws InterruptedException, ExecutionException { + synchronized (lock) { + while (state == RUNNING) { + lock.wait(); + } + } + if (state == COMPLETED) { + return value; + } + throw new ExecutionException(exception); + } + + @Override + public T get(long timeout, TimeUnit unit) throws ExecutionException { + synchronized (lock) { + while (state == RUNNING) { + try { + lock.wait(unit.toMillis(timeout)); + } catch (InterruptedException e) { + LOGGER.warn("Interrupted!", e); + Thread.currentThread().interrupt(); + } + } + } + + if (state == COMPLETED) { + return value; + } + throw new ExecutionException(exception); + } +} +``` + +With `PromiseSupport` in place we can implement the actual `Promise`. + +```java +public class Promise extends PromiseSupport { + + private Runnable fulfillmentAction; + private Consumer exceptionHandler; + + public Promise() { + } + + @Override + public void fulfill(T value) { + super.fulfill(value); + postFulfillment(); + } + + @Override + public void fulfillExceptionally(Exception exception) { + super.fulfillExceptionally(exception); + handleException(exception); + postFulfillment(); + } + + private void handleException(Exception exception) { + if (exceptionHandler == null) { + return; + } + exceptionHandler.accept(exception); + } + + private void postFulfillment() { + if (fulfillmentAction == null) { + return; + } + fulfillmentAction.run(); + } + + public Promise fulfillInAsync(final Callable task, Executor executor) { + executor.execute(() -> { + try { + fulfill(task.call()); + } catch (Exception ex) { + fulfillExceptionally(ex); + } + }); + return this; + } + + public Promise thenAccept(Consumer action) { + var dest = new Promise(); + fulfillmentAction = new ConsumeAction(this, dest, action); + return dest; + } + + public Promise onError(Consumer exceptionHandler) { + this.exceptionHandler = exceptionHandler; + return this; + } + + public Promise thenApply(Function func) { + Promise dest = new Promise<>(); + fulfillmentAction = new TransformAction<>(this, dest, func); + return dest; + } + + private class ConsumeAction implements Runnable { + + private final Promise src; + private final Promise dest; + private final Consumer action; + + private ConsumeAction(Promise src, Promise dest, Consumer action) { + this.src = src; + this.dest = dest; + this.action = action; + } + + @Override + public void run() { + try { + action.accept(src.get()); + dest.fulfill(null); + } catch (Throwable throwable) { + dest.fulfillExceptionally((Exception) throwable.getCause()); + } + } + } + + private class TransformAction implements Runnable { + + private final Promise src; + private final Promise dest; + private final Function func; + + private TransformAction(Promise src, Promise dest, Function func) { + this.src = src; + this.dest = dest; + this.func = func; + } + + @Override + public void run() { + try { + dest.fulfill(func.apply(src.get())); + } catch (Throwable throwable) { + dest.fulfillExceptionally((Exception) throwable.getCause()); + } + } + } +} +``` + +Now we can show the full example in action. Here's how to download and count the number of lines in +a file using `Promise`. + +```java + countLines().thenAccept( + count -> { + LOGGER.info("Line count is: {}", count); + taskCompleted(); + } + ); + + private Promise countLines() { + return download(DEFAULT_URL).thenApply(Utility::countLines); + } + + private Promise download(String urlString) { + return new Promise() + .fulfillInAsync( + () -> Utility.downloadFile(urlString), executor) + .onError( + throwable -> { + throwable.printStackTrace(); + taskCompleted(); + } + ); + } +``` + +### Class diagram + +![alt text](./etc/promise.png "Promise") + +### Applicability + +Promise pattern is applicable in concurrent programming when some work needs to be done +asynchronously and: + +* Code maintainability and readability suffers due to callback hell. +* You need to compose promises and need better error handling for asynchronous tasks. +* You want to use functional style of programming. + + +## Real world examples + +* [java.util.concurrent.CompletableFuture](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/CompletableFuture.html) +* [Guava ListenableFuture](https://github.com/google/guava/wiki/ListenableFutureExplained) + +## Related Patterns + + * [Async Method Invocation](https://java-design-patterns.com/patterns/async-method-invocation/) + * [Callback](https://java-design-patterns.com/patterns/callback/) + +### Tutorials + +* [Guide To CompletableFuture](https://www.baeldung.com/java-completablefuture) + +### Credits + +* [You are missing the point to Promises](https://gist.github.com/domenic/3889970) +* [Functional style callbacks using CompletableFuture](https://www.infoq.com/articles/Functional-Style-Callbacks-Using-CompletableFuture) +* [Java 8 in Action: Lambdas, Streams, and functional-style programming](https://www.amazon.com/gp/product/1617291994/ref=as_li_qf_asin_il_tl?ie=UTF8&tag=javadesignpat-20&creative=9325&linkCode=as2&creativeASIN=1617291994&linkId=995af46887bb7b65e6c788a23eaf7146) +* [Modern Java in Action: Lambdas, streams, functional and reactive programming](https://www.amazon.com/gp/product/1617293563/ref=as_li_qf_asin_il_tl?ie=UTF8&tag=javadesignpat-20&creative=9325&linkCode=as2&creativeASIN=1617293563&linkId=f70fe0d3e1efaff89554a6479c53759c) + +## Property +[⬆](#content) + +--- +layout: pattern +title: Property +folder: property +permalink: /patterns/property/ +categories: Creational +tags: + - Instantiation +--- + +### Intent +Create hierarchy of objects and new objects using already existing +objects as parents. + +### Class diagram +![alt text](./etc/property.png "Property") + +### Applicability +Use the Property pattern when + +* When you like to have objects with dynamic set of fields and prototype inheritance + +## Real world examples + +* [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Inheritance_and_the_prototype_chain) prototype inheritance + +## Prototype +[⬆](#content) + +--- +layout: pattern +title: Prototype +folder: prototype +permalink: /patterns/prototype/ +categories: Creational +tags: + - Gang Of Four + - Instantiation +--- + +### Intent + +Specify the kinds of objects to create using a prototypical instance, and create new objects by +copying this prototype. + +### Explanation + +First it should be noted that Prototype pattern is not used to gain performance benefits. It's only +used for creating new objects from prototype instance. + +Real world example + +> Remember Dolly? The sheep that was cloned! Lets not get into the details but the key point here is +> that it is all about cloning. + +In plain words + +> Create object based on an existing object through cloning. + +Wikipedia says + +> The prototype pattern is a creational design pattern in software development. It is used when the +> type of objects to create is determined by a prototypical instance, which is cloned to produce new +> objects. + +In short, it allows you to create a copy of an existing object and modify it to your needs, instead +of going through the trouble of creating an object from scratch and setting it up. + +**Programmatic Example** + +In Java, it can be easily done by implementing `Cloneable` and overriding `clone` from `Object` + +```java +class Sheep implements Cloneable { + private String name; + public Sheep(String name) { this.name = name; } + public void setName(String name) { this.name = name; } + public String getName() { return name; } + @Override + public Sheep clone() { + try { + return (Sheep)super.clone(); + } catch(CloneNotSuportedException) { + throw new InternalError(); + } + } +} +``` + +Then it can be cloned like below: + +```java +var original = new Sheep("Jolly"); +System.out.println(original.getName()); // Jolly + +// Clone and modify what is required +var cloned = original.clone(); +cloned.setName("Dolly"); +System.out.println(cloned.getName()); // Dolly +``` + +### Class diagram + +![alt text](./etc/prototype.urm.png "Prototype pattern class diagram") + +### Applicability + +Use the Prototype pattern when a system should be independent of how its products are created, +composed, represented and + +* When the classes to instantiate are specified at run-time, for example, by dynamic loading. +* To avoid building a class hierarchy of factories that parallels the class hierarchy of products. +* When instances of a class can have one of only a few different combinations of state. It may be +more convenient to install a corresponding number of prototypes and clone them rather than +instantiating the class manually, each time with the appropriate state. +* When object creation is expensive compared to cloning. + +## Real world examples + +* [java.lang.Object#clone()](http://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#clone%28%29) + +### Credits + +* [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/gp/product/0201633612/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0201633612&linkCode=as2&tag=javadesignpat-20&linkId=675d49790ce11db99d90bde47f1aeb59) +* [Head First Design Patterns: A Brain-Friendly Guide](https://www.amazon.com/gp/product/0596007124/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596007124&linkCode=as2&tag=javadesignpat-20&linkId=6b8b6eea86021af6c8e3cd3fc382cb5b) + +## Proxy +[⬆](#content) + +--- +layout: pattern +title: Proxy +folder: proxy +permalink: /patterns/proxy/ +categories: Structural +tags: + - Gang Of Four + - Decoupling +--- + +### Also known as + +Surrogate + +### Intent + +Provide a surrogate or placeholder for another object to control access to it. + +### Explanation + +Real world example + +> Imagine a tower where the local wizards go to study their spells. The ivory tower can only be +> accessed through a proxy which ensures that only the first three wizards can enter. Here the proxy +> represents the functionality of the tower and adds access control to it. + +In plain words + +> Using the proxy pattern, a class represents the functionality of another class. + +Wikipedia says + +> A proxy, in its most general form, is a class functioning as an interface to something else. +> A proxy is a wrapper or agent object that is being called by the client to access the real serving +> object behind the scenes. Use of the proxy can simply be forwarding to the real object, or can +> provide additional logic. In the proxy extra functionality can be provided, for example caching +> when operations on the real object are resource intensive, or checking preconditions before +> operations on the real object are invoked. + +**Programmatic Example** + +Taking our wizard tower example from above. Firstly we have the `WizardTower` interface and the +`IvoryTower` class. + +```java +public interface WizardTower { + + void enter(Wizard wizard); +} + +public class IvoryTower implements WizardTower { + + private static final Logger LOGGER = LoggerFactory.getLogger(IvoryTower.class); + + public void enter(Wizard wizard) { + LOGGER.info("{} enters the tower.", wizard); + } + +} +``` + +Then a simple `Wizard` class. + +```java +public class Wizard { + + private final String name; + + public Wizard(String name) { + this.name = name; + } + + @Override + public String toString() { + return name; + } +} +``` + +Then we have the `WizardTowerProxy` to add access control to `WizardTower`. + +```java +public class WizardTowerProxy implements WizardTower { + + private static final Logger LOGGER = LoggerFactory.getLogger(WizardTowerProxy.class); + + private static final int NUM_WIZARDS_ALLOWED = 3; + + private int numWizards; + + private final WizardTower tower; + + public WizardTowerProxy(WizardTower tower) { + this.tower = tower; + } + + @Override + public void enter(Wizard wizard) { + if (numWizards < NUM_WIZARDS_ALLOWED) { + tower.enter(wizard); + numWizards++; + } else { + LOGGER.info("{} is not allowed to enter!", wizard); + } + } +} +``` + +And here is the tower entering scenario. + +```java +var proxy = new WizardTowerProxy(new IvoryTower()); +proxy.enter(new Wizard("Red wizard")); +proxy.enter(new Wizard("White wizard")); +proxy.enter(new Wizard("Black wizard")); +proxy.enter(new Wizard("Green wizard")); +proxy.enter(new Wizard("Brown wizard")); +``` + +Program output: + +``` +Red wizard enters the tower. +White wizard enters the tower. +Black wizard enters the tower. +Green wizard is not allowed to enter! +Brown wizard is not allowed to enter! +``` + +### Class diagram + +![alt text](./etc/proxy.urm.png "Proxy pattern class diagram") + +### Applicability + +Proxy is applicable whenever there is a need for a more versatile or sophisticated reference to an +object than a simple pointer. Here are several common situations in which the Proxy pattern is +applicable. + +* Remote proxy provides a local representative for an object in a different address space. +* Virtual proxy creates expensive objects on demand. +* Protection proxy controls access to the original object. Protection proxies are useful when +objects should have different access rights. + +## Typical Use Case + +* Control access to another object +* Lazy initialization +* Implement logging +* Facilitate network connection +* Count references to an object + +### Tutorials + +* [Controlling Access With Proxy Pattern](http://java-design-patterns.com/blog/controlling-access-with-proxy-pattern/) + +### Known uses + +* [java.lang.reflect.Proxy](http://docs.oracle.com/javase/8/docs/api/java/lang/reflect/Proxy.html) +* [Apache Commons Proxy](https://commons.apache.org/proper/commons-proxy/) +* Mocking frameworks [Mockito](https://site.mockito.org/), +[Powermock](https://powermock.github.io/), [EasyMock](https://easymock.org/) + +### Related patterns + +* [Ambassador](https://java-design-patterns.com/patterns/ambassador/) + +### Credits + +* [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/gp/product/0201633612/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0201633612&linkCode=as2&tag=javadesignpat-20&linkId=675d49790ce11db99d90bde47f1aeb59) +* [Head First Design Patterns: A Brain-Friendly Guide](https://www.amazon.com/gp/product/0596007124/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596007124&linkCode=as2&tag=javadesignpat-20&linkId=6b8b6eea86021af6c8e3cd3fc382cb5b) + +## Queue Based Load Leveling +[⬆](#content) + +--- +layout: pattern +title: Queue based load leveling +folder: queue-load-leveling +permalink: /patterns/queue-load-leveling/ +categories: Concurrency +tags: + - Decoupling + - Performance + - Cloud distributed +--- + +### Intent +Use a queue that acts as a buffer between a task and a service that it invokes in order to smooth +intermittent heavy loads that may otherwise cause the service to fail or the task to time out. +This pattern can help to minimize the impact of peaks in demand on availability and responsiveness +for both the task and the service. + +### Class diagram +![alt text](./etc/queue-load-leveling.gif "queue-load-leveling") + +### Applicability + +* This pattern is ideally suited to any type of application that uses services that may be subject to overloading. +* This pattern might not be suitable if the application expects a response from the service with minimal latency. + +### Tutorials +* [Queue-Based Load Leveling Pattern](http://java-design-patterns.com/blog/queue-load-leveling/) + +## Real world example + +* A Microsoft Azure web role stores data by using a separate storage service. If a large number of instances of the web role run concurrently, it is possible that the storage service could be overwhelmed and be unable to respond to requests quickly enough to prevent these requests from timing out or failing. + +### Credits + +* [Queue-Based Load Leveling pattern](https://docs.microsoft.com/en-us/azure/architecture/patterns/queue-based-load-leveling) + +## Reactor +[⬆](#content) + +--- +layout: pattern +title: Reactor +folder: reactor +permalink: /patterns/reactor/ +pumlformat: svg +categories: Concurrency +tags: + - Performance + - Reactive +--- + +### Intent +The Reactor design pattern handles service requests that are delivered concurrently to an application by one or more clients. The application can register specific handlers for processing which are called by reactor on specific events. Dispatching of event handlers is performed by an initiation dispatcher, which manages the registered event handlers. Demultiplexing of service requests is performed by a synchronous event demultiplexer. + +### Class diagram +![Reactor](./etc/reactor.png "Reactor") + +### Applicability +Use Reactor pattern when + +* A server application needs to handle concurrent service requests from multiple clients. +* A server application needs to be available for receiving requests from new clients even when handling older client requests. +* A server must maximize throughput, minimize latency and use CPU efficiently without blocking. + +## Real world examples + +* [Spring Reactor](http://projectreactor.io/) + +### Credits + +* [Douglas C. Schmidt - Reactor](https://www.dre.vanderbilt.edu/~schmidt/PDF/Reactor.pdf) +* [Pattern Oriented Software Architecture Volume 2: Patterns for Concurrent and Networked Objects](https://www.amazon.com/gp/product/0471606952/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0471606952&linkCode=as2&tag=javadesignpat-20&linkId=889e4af72dca8261129bf14935e0f8dc) +* [Doug Lea - Scalable IO in Java](http://gee.cs.oswego.edu/dl/cpjslides/nio.pdf) +* [Netty](http://netty.io/) + +## Reader Writer Lock +[⬆](#content) + +--- +layout: pattern +title: Reader Writer Lock +folder: reader-writer-lock +permalink: /patterns/reader-writer-lock/ +categories: Concurrency +tags: + - Performance +--- + +### Intent + +Suppose we have a shared memory area with the basic constraints detailed above. It is possible to protect the shared data behind a mutual exclusion mutex, in which case no two threads can access the data at the same time. However, this solution is suboptimal, because it is possible that a reader R1 might have the lock, and then another reader R2 requests access. It would be foolish for R2 to wait until R1 was done before starting its own read operation; instead, R2 should start right away. This is the motivation for the Reader Writer Lock pattern. + +### Class diagram +![alt text](./etc/reader-writer-lock.png "Reader writer lock") + +### Applicability + +Application need to increase the performance of resource synchronize for multiple thread, in particularly there are mixed read/write operations. + +## Real world examples + +* [Java Reader Writer Lock](https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/locks/ReadWriteLock.html) + +### Credits + +* [Readers–writer lock](https://en.wikipedia.org/wiki/Readers%E2%80%93writer_lock) +* [Readers–writers_problem](https://en.wikipedia.org/wiki/Readers%E2%80%93writers_problem) + +## Registry +[⬆](#content) + +--- +layout: pattern +title: Registry +folder: registry +permalink: /patterns/registry/ +categories: Creational +tags: + - Instantiation +--- + +### Intent +Stores the objects of a single class and provide a global point of access to them. +Similar to Multiton pattern, only difference is that in a registry there is no restriction on the number of objects. + +### Explanation + +In Plain Words + +> Registry is a well-known object that other objects can use to find common objects and services. + +**Programmatic Example** +Below is a `Customer` Class + +```java +public class Customer { + + private final String id; + private final String name; + + public Customer(String id, String name) { + this.id = id; + this.name = name; + } + + public String getId() { + return id; + } + + public String getName() { + return name; + } + +} +``` + +This registry of the `Customer` objects is `CustomerRegistry` +```java +public final class CustomerRegistry { + + private static final CustomerRegistry instance = new CustomerRegistry(); + + public static CustomerRegistry getInstance() { + return instance; + } + + private final Map customerMap; + + private CustomerRegistry() { + customerMap = new ConcurrentHashMap<>(); + } + + public Customer addCustomer(Customer customer) { + return customerMap.put(customer.getId(), customer); + } + + public Customer getCustomer(String id) { + return customerMap.get(id); + } + +} +``` + +### Class diagram +![Registry](./etc/registry.png) + +### Applicability +Use Registry pattern when + +* client wants reference of some object, so client can lookup for that object in the object's registry. + +### Consequences +Large number of bulky objects added to registry would result in a lot of memory consumption as objects in the registry are not garbage collected. + +### Credits +* https://www.martinfowler.com/eaaCatalog/registry.html +* https://wiki.c2.com/?RegistryPattern + + +## Repository +[⬆](#content) + +--- +layout: pattern +title: Repository +folder: repository +permalink: /patterns/repository/ +categories: Architectural +tags: + - Data access +--- + +### Intent + +Repository layer is added between the domain and data mapping layers to isolate domain objects from +details of the database access code and to minimize scattering and duplication of query code. The +Repository pattern is especially useful in systems where number of domain classes is large or heavy +querying is utilized. + +### Explanation + +Real world example + +> Let's say we need a persistent data store for persons. Adding new persons and searching for them +> according to different criteria must be easy. + +In plain words + +> Repository architectural pattern creates a uniform layer of data repositories that can be used for +> CRUD operations. + +[Microsoft documentation](https://docs.microsoft.com/en-us/dotnet/architecture/microservices/microservice-ddd-cqrs-patterns/infrastructure-persistence-layer-design) says + +> Repositories are classes or components that encapsulate the logic required to access data sources. +> They centralize common data access functionality, providing better maintainability and decoupling +> the infrastructure or technology used to access databases from the domain model layer. + +**Programmatic Example** + +Let's first look at the person entity that we need to persist. + +```java +@Entity +public class Person { + + @Id + @GeneratedValue + private Long id; + private String name; + private String surname; + private int age; + + public Person() { + } + + public Person(String name, String surname, int age) { + this.name = name; + this.surname = surname; + this.age = age; + } + + // getters and setters -> + ... +} +``` + +We are using Spring Data to create the `PersonRepository` so it becomes really simple. + +```java +@Repository +public interface PersonRepository + extends CrudRepository, JpaSpecificationExecutor { + + Person findByName(String name); +} +``` + +Additionally we define a helper class `PersonSpecifications` for specification queries. + +```java +public class PersonSpecifications { + + public static class AgeBetweenSpec implements Specification { + + private final int from; + + private final int to; + + public AgeBetweenSpec(int from, int to) { + this.from = from; + this.to = to; + } + + @Override + public Predicate toPredicate(Root root, CriteriaQuery query, CriteriaBuilder cb) { + return cb.between(root.get("age"), from, to); + } + + } + + public static class NameEqualSpec implements Specification { + + public String name; + + public NameEqualSpec(String name) { + this.name = name; + } + + public Predicate toPredicate(Root root, CriteriaQuery query, CriteriaBuilder cb) { + return cb.equal(root.get("name"), this.name); + } + } + +} +``` + +And here's the repository example in action. + +```java + var peter = new Person("Peter", "Sagan", 17); + var nasta = new Person("Nasta", "Kuzminova", 25); + var john = new Person("John", "lawrence", 35); + var terry = new Person("Terry", "Law", 36); + + repository.save(peter); + repository.save(nasta); + repository.save(john); + repository.save(terry); + + LOGGER.info("Count Person records: {}", repository.count()); + + var persons = (List) repository.findAll(); + persons.stream().map(Person::toString).forEach(LOGGER::info); + + nasta.setName("Barbora"); + nasta.setSurname("Spotakova"); + repository.save(nasta); + + repository.findById(2L).ifPresent(p -> LOGGER.info("Find by id 2: {}", p)); + repository.deleteById(2L); + + LOGGER.info("Count Person records: {}", repository.count()); + + repository + .findOne(new PersonSpecifications.NameEqualSpec("John")) + .ifPresent(p -> LOGGER.info("Find by John is {}", p)); + + persons = repository.findAll(new PersonSpecifications.AgeBetweenSpec(20, 40)); + + LOGGER.info("Find Person with age between 20,40: "); + persons.stream().map(Person::toString).forEach(LOGGER::info); + + repository.deleteAll(); +``` + +Program output: + +``` +Count Person records: 4 +Person [id=1, name=Peter, surname=Sagan, age=17] +Person [id=2, name=Nasta, surname=Kuzminova, age=25] +Person [id=3, name=John, surname=lawrence, age=35] +Person [id=4, name=Terry, surname=Law, age=36] +Find by id 2: Person [id=2, name=Barbora, surname=Spotakova, age=25] +Count Person records: 3 +Find by John is Person [id=3, name=John, surname=lawrence, age=35] +Find Person with age between 20,40: +Person [id=3, name=John, surname=lawrence, age=35] +Person [id=4, name=Terry, surname=Law, age=36] +``` + +### Class diagram + +![alt text](./etc/repository.png "Repository") + +### Applicability + +Use the Repository pattern when + +* The number of domain objects is large. +* You want to avoid duplication of query code. +* You want to keep the database querying code in single place. +* You have multiple data sources. + +## Real world examples + +* [Spring Data](http://projects.spring.io/spring-data/) + +### Credits + +* [Don’t use DAO, use Repository](http://thinkinginobjects.com/2012/08/26/dont-use-dao-use-repository/) +* [Advanced Spring Data JPA - Specifications and Querydsl](https://spring.io/blog/2011/04/26/advanced-spring-data-jpa-specifications-and-querydsl/) +* [Repository Pattern Benefits and Spring Implementation](https://stackoverflow.com/questions/40068965/repository-pattern-benefits-and-spring-implementation) +* [Patterns of Enterprise Application Architecture](https://www.amazon.com/gp/product/0321127420/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0321127420&linkCode=as2&tag=javadesignpat-20&linkId=d9f7d37b032ca6e96253562d075fcc4a) +* [Design patterns that I often avoid: Repository pattern](https://www.infoworld.com/article/3117713/design-patterns-that-i-often-avoid-repository-pattern.html) + +## Resource Acquisition is Initialization +[⬆](#content) + +--- +layout: pattern +title: Resource Acquisition Is Initialization +folder: resource-acquisition-is-initialization +permalink: /patterns/resource-acquisition-is-initialization/ +categories: Idiom +tags: + - Data access +--- + +### Intent +Resource Acquisition Is Initialization pattern can be used to implement exception safe resource management. + +### Class diagram +![alt text](./etc/resource-acquisition-is-initialization.png "Resource Acquisition Is Initialization") + +### Applicability +Use the Resource Acquisition Is Initialization pattern when + +* You have resources that must be closed in every condition + +## Retry +[⬆](#content) + +--- +layout: pattern +title: Retry +folder: retry +permalink: /patterns/retry/ +categories: Behavioral +tags: + - Performance + - Cloud distributed +--- + +### Intent + +Transparently retry certain operations that involve communication with external resources, +particularly over the network, isolating calling code from the retry implementation details. + +### Explanation + +Retry pattern consists retrying operations on remote resources over the network a set number of +times. It closely depends on both business and technical requirements: How much time will the +business allow the end user to wait while the operation finishes? What are the performance +characteristics of the remote resource during peak loads as well as our application as more threads +are waiting for the remote resource's availability? Among the errors returned by the remote service, +which can be safely ignored in order to retry? Is the operation +[idempotent](https://en.wikipedia.org/wiki/Idempotence)? + +Another concern is the impact on the calling code by implementing the retry mechanism. The retry +mechanics should ideally be completely transparent to the calling code (service interface remains +unaltered). There are two general approaches to this problem: From an enterprise architecture +standpoint (strategic), and a shared library standpoint (tactical). + +From a strategic point of view, this would be solved by having requests redirected to a separate +intermediary system, traditionally an [ESB](https://en.wikipedia.org/wiki/Enterprise_service_bus), +but more recently a [Service Mesh](https://medium.com/microservices-in-practice/service-mesh-for-microservices-2953109a3c9a). + +From a tactical point of view, this would be solved by reusing shared libraries like +[Hystrix](https://github.com/Netflix/Hystrix) (please note that Hystrix is a complete implementation +of the [Circuit Breaker](https://java-design-patterns.com/patterns/circuit-breaker/) pattern, of +which the Retry pattern can be considered a subset of). This is the type of solution showcased in +the simple example that accompanies this `README.md`. + +Real world example + +> Our application uses a service providing customer information. Once in a while the service seems +> to be flaky and can return errors or sometimes it just times out. To circumvent these problems we +> apply the retry pattern. + +In plain words + +> Retry pattern transparently retries failed operations over network. + +[Microsoft documentation](https://docs.microsoft.com/en-us/azure/architecture/patterns/retry) says + +> Enable an application to handle transient failures when it tries to connect to a service or +> network resource, by transparently retrying a failed operation. This can improve the stability of +> the application. + +**Programmatic Example** + +In our hypothetical application, we have a generic interface for all operations on remote +interfaces. + +```java +public interface BusinessOperation { + T perform() throws BusinessException; +} +``` + +And we have an implementation of this interface that finds our customers by looking up a database. + +```java +public final class FindCustomer implements BusinessOperation { + @Override + public String perform() throws BusinessException { + ... + } +} +``` + +Our `FindCustomer` implementation can be configured to throw `BusinessException`s before returning +the customer's ID, thereby simulating a flaky service that intermittently fails. Some exceptions, +like the `CustomerNotFoundException`, are deemed to be recoverable after some hypothetical analysis +because the root cause of the error stems from "some database locking issue". However, the +`DatabaseNotAvailableException` is considered to be a definite showstopper - the application should +not attempt to recover from this error. + +We can model a recoverable scenario by instantiating `FindCustomer` like this: + +```java +final var op = new FindCustomer( + "12345", + new CustomerNotFoundException("not found"), + new CustomerNotFoundException("still not found"), + new CustomerNotFoundException("don't give up yet!") +); +``` + +In this configuration, `FindCustomer` will throw `CustomerNotFoundException` three times, after +which it will consistently return the customer's ID (`12345`). + +In our hypothetical scenario, our analysts indicate that this operation typically fails 2-4 times +for a given input during peak hours, and that each worker thread in the database subsystem typically +needs 50ms to "recover from an error". Applying these policies would yield something like this: + +```java +final var op = new Retry<>( + new FindCustomer( + "1235", + new CustomerNotFoundException("not found"), + new CustomerNotFoundException("still not found"), + new CustomerNotFoundException("don't give up yet!") + ), + 5, + 100, + e -> CustomerNotFoundException.class.isAssignableFrom(e.getClass()) +); +``` + +Executing `op` once would automatically trigger at most 5 retry attempts, with a 100 millisecond +delay between attempts, ignoring any `CustomerNotFoundException` thrown while trying. In this +particular scenario, due to the configuration for `FindCustomer`, there will be 1 initial attempt +and 3 additional retries before finally returning the desired result `12345`. + +If our `FindCustomer` operation were instead to throw a fatal `DatabaseNotFoundException`, which we +were instructed not to ignore, but more importantly we did not instruct our `Retry` to ignore, then +the operation would have failed immediately upon receiving the error, not matter how many attempts +were left. + +### Class diagram + +![alt text](./etc/retry.png "Retry") + +### Applicability + +Whenever an application needs to communicate with an external resource, particularly in a cloud +environment, and if the business requirements allow it. + +### Consequences + +**Pros:** + +* Resiliency +* Provides hard data on external failures + +**Cons:** + +* Complexity +* Operations maintenance + +## Related Patterns + +* [Circuit Breaker](https://java-design-patterns.com/patterns/circuit-breaker/) + +### Credits + +* [Retry pattern](https://docs.microsoft.com/en-us/azure/architecture/patterns/retry) +* [Cloud Design Patterns: Prescriptive Architecture Guidance for Cloud Applications](https://www.amazon.com/gp/product/1621140369/ref=as_li_tl?ie=UTF8&tag=javadesignpat-20&camp=1789&creative=9325&linkCode=as2&creativeASIN=1621140369&linkId=3e3f686af5e60a7a453b48adb286797b) + + +## Role Object +[⬆](#content) + +--- +layout: pattern +title: Role Object +folder: role-object +permalink: /patterns/role-object/ +categories: Structural +tags: + - Extensibility +--- + +### Also known as +Post pattern, Extension Object pattern + +### Intent +Adapt an object to different client’s needs through transparently attached role objects, each one representing a role +the object has to play in that client’s context. The object manages its role set dynamically. By representing roles as +individual objects, different contexts are kept separate and system configuration is simplified. + +### Class diagram +![alt text](./etc/role-object.urm.png "Role Object pattern class diagram") + +### Applicability +Use the Role Object pattern, if: + +- You want to handle a key abstraction in different contexts and you do not want to put the resulting context specific interfaces into the same class interface. +- You want to handle the available roles dynamically so that they can be attached and removed on demand, that is at runtime, rather than fixing them statically at compile-time. +- You want to treat the extensions transparently and need to preserve the logical object identity of the resultingobject conglomerate. +- You want to keep role/client pairs independent from each other so that changes to a role do not affect clients that are not interested in that role. + +### Credits + +- [Hillside - Role object pattern](https://hillside.net/plop/plop97/Proceedings/riehle.pdf) +- [Role object](http://wiki.c2.com/?RoleObject) +- [Fowler - Dealing with roles](https://martinfowler.com/apsupp/roles.pdf) + + +## Saga +[⬆](#content) + +--- +layout: pattern +title: Saga +folder: saga +permalink: /patterns/saga/ +categories: Concurrency +tags: + - Cloud distributed +--- + +### Also known as +This pattern has a similar goal with two-phase commit (XA transaction) + +### Intent +This pattern is used in distributed services to perform a group of operations atomically. +This is an analog of transaction in a database but in terms of microservices architecture this is executed +in a distributed environment + +### Explanation +A saga is a sequence of local transactions in a certain context. If one transaction fails for some reason, +the saga executes compensating transactions(rollbacks) to undo the impact of the preceding transactions. +There are two types of Saga: + +- Choreography-Based Saga. +In this approach, there is no central orchestrator. +Each service participating in the Saga performs their transaction and publish events. +The other services act upon those events and perform their transactions. +Also, they may or not publish other events based on the situation. + +- Orchestration-Based Saga +In this approach, there is a Saga orchestrator that manages all the transactions and directs +the participant services to execute local transactions based on events. +This orchestrator can also be though of as a Saga Manager. + +### Class diagram +![alt text](./etc/saga.urm.png "Saga pattern class diagram") + +### Applicability +Use the Saga pattern, if: + +- you need to perform a group of operations related to different microservices atomically +- you need to rollback changes in different places in case of failure one of the operation +- you need to take care of data consistency in different places including different databases +- you can not use 2PC(two phase commit) + +### Credits + +- [Pattern: Saga](https://microservices.io/patterns/data/saga.html) +- [Saga distributed transactions pattern](https://docs.microsoft.com/en-us/azure/architecture/reference-architectures/saga/saga) + + +## Separated Interface +[⬆](#content) + +--- +layout: pattern +title: Separated Interface +folder: separated-interface +permalink: /patterns/separated-interface/ +categories: Structural +tags: + - Decoupling +--- + + +### Intent + +Separate the interface definition and implementation in different packages. This allows the client +to be completely unaware of the implementation. + +### Explanation + +Real world example + +> An Invoice generator may be created with ability to use different Tax calculators that may be +> added in the invoice depending upon type of purchase, region etc. + +In plain words + +> Separated interface pattern encourages to keep the implementations of an interface decoupled from +> the client and its definition, so the client is not dependent on the implementation. + +A client code may abstract some specific functionality to an interface, and define the definition of +the interface as an SPI ([Service Programming Interface](https://en.wikipedia.org/wiki/Service_provider_interface) +is an API intended and open to be implemented or extended by a third party). Another package may +implement this interface definition with a concrete logic, which will be injected into the client +code at runtime (with a third class, injecting the implementation in the client) or at compile time +(using Plugin pattern with some configurable file). + +**Programmatic Example** + +**Client** + +`InvoiceGenerator` class accepts the cost of the product and calculates the total +amount payable inclusive of tax. + +```java +public class InvoiceGenerator { + + private final TaxCalculator taxCalculator; + + private final double amount; + + public InvoiceGenerator(double amount, TaxCalculator taxCalculator) { + this.amount = amount; + this.taxCalculator = taxCalculator; + } + + public double getAmountWithTax() { + return amount + taxCalculator.calculate(amount); + } + +} +``` + +The tax calculation logic is delegated to the `TaxCalculator` interface. + +```java +public interface TaxCalculator { + + double calculate(double amount); + +} +``` + +**Implementation package** + +In another package (which the client is completely unaware of) there exist multiple implementations +of the `TaxCalculator` interface. `ForeignTaxCalculator` is one of them which levies 60% tax +for international products. + +```java +public class ForeignTaxCalculator implements TaxCalculator { + + public static final double TAX_PERCENTAGE = 60; + + @Override + public double calculate(double amount) { + return amount * TAX_PERCENTAGE / 100.0; + } + +} +``` + +Another is `DomesticTaxCalculator` which levies 20% tax for international products. + +```java +public class DomesticTaxCalculator implements TaxCalculator { + + public static final double TAX_PERCENTAGE = 20; + + @Override + public double calculate(double amount) { + return amount * TAX_PERCENTAGE / 100.0; + } + +} +``` + +These both implementations are instantiated and injected in the client class by the ```App.java``` +class. + +```java + var internationalProductInvoice = new InvoiceGenerator(PRODUCT_COST, new ForeignTaxCalculator()); + + LOGGER.info("Foreign Tax applied: {}", "" + internationalProductInvoice.getAmountWithTax()); + + var domesticProductInvoice = new InvoiceGenerator(PRODUCT_COST, new DomesticTaxCalculator()); + + LOGGER.info("Domestic Tax applied: {}", "" + domesticProductInvoice.getAmountWithTax()); +``` + +### Class diagram + +![alt text](./etc/class_diagram.png "Separated Interface") + +### Applicability + +Use the Separated interface pattern when + +* You are developing a framework package, and your framework needs to call some application code through interfaces. +* You have separate packages implementing the functionalities which may be plugged in your client code at runtime or compile-time. +* Your code resides in a layer that is not allowed to call the interface implementation layer by rule. For example, a domain layer needs to call a data mapper. + +### Tutorial + +* [Separated Interface Tutorial](https://www.youtube.com/watch?v=d3k-hOA7k2Y) + +### Credits + +* [Martin Fowler](https://www.martinfowler.com/eaaCatalog/separatedInterface.html) +* [Patterns of Enterprise Application Architecture](https://www.amazon.com/gp/product/0321127420/ref=as_li_qf_asin_il_tl?ie=UTF8&tag=javadesignpat-20&creative=9325&linkCode=as2&creativeASIN=0321127420&linkId=e08dfb7f2cf6153542ef1b5a00b10abc) + +## Servant +[⬆](#content) + +--- +layout: pattern +title: Servant +folder: servant +permalink: /patterns/servant/ +categories: Behavioral +tags: + - Decoupling +--- + +### Intent +Servant is used for providing some behavior to a group of classes. +Instead of defining that behavior in each class - or when we cannot factor out +this behavior in the common parent class - it is defined once in the Servant. + +### Class diagram +![alt text](./etc/servant-pattern.png "Servant") + +### Applicability +Use the Servant pattern when + +* When we want some objects to perform a common action and don't want to define this action as a method in every class. + +### Credits + +* [Let's Modify the Objects-First Approach into Design-Patterns-First](http://edu.pecinovsky.cz/papers/2006_ITiCSE_Design_Patterns_First.pdf) + + +## Serverless +[⬆](#content) + +--- +layout: pattern +title: Serverless +folder: serverless +permalink: /patterns/serverless/ +categories: Architectural +tags: + - Cloud distributed +--- + +## Serverless + +Serverless eliminates the need to plan for infrastructure and let's you focus on your +application. + +Following are optimization katas you should be aware of while building a serverless +applications + +* The Lean function + * Concise logic - Use functions to transform, not transport (utilize some of the + integration available from the provider to transport), and make sure you read only + what you need + * Efficient/single purpose code - avoid conditional/routing logic and break down + into individual functions, avoid "fat"/monolithic functions and control the + dependencies in the function deployment package to reduce the load time for your + function + * ephemeral environment - Utilize container start for expensive initializations +* Eventful Invocations + * Succinct payloads - Scrutinize the event as much as possible, and watch for + payload constraints (async - 128K) + * resilient routing - Understand retry policies and leverage dead letter queues + (SQS or SNS for replays) and remember retries count as invocations + * concurrent execution - lambda thinks of it's scale in terms of concurrency and + its not request based/duration based. Lambda will spin up the number of instances + based on the request. +* Coordinated calls + * Decoupled via APIs - best practice to setup your application is to have API's as + contracts that ensures separation of concerns + * scale-matched downstream - make sure when Lambda is calling downstream + components, you are matching scale configuration to it (by specifying max + concurrency based on downstream services) + * secured - Always ask a question, do I need a VPC? +* Serviceful operations + * Automated - use automated tools to manage and maintain the stack + * monitored applications - use monitoring services to get holistic view of your + serverless applications + +### Intent + +Whether to reduce your infrastructure costs, shrink the time you spend on ops tasks, +simplify your deployment processes, reach infinite scalability, serverless cuts time +to market in half. + +### Explanation + +Serverless computing is a cloud computing execution model in which the cloud provider +dynamically manages the allocation of machine resources. Pricing is based on the +actual amount of resources consumed by an application, rather than on pre-purchased +units of capacity. + +### Class diagram +![alt text](./etc/serverless.urm.png "Serverless pattern class diagram") + +## Serverless framework + +[Serverless](https://serverless.com/) is a toolkit for deploying and operating serverless architectures. + +## (Function as a Service or "FaaS") + +The term ‘Serverless’ is confusing since with such applications there are both server +hardware and server processes running somewhere, but the difference to normal +approaches is that the organization building and supporting a ‘Serverless’ application + is not looking after the hardware or the processes - they are outsourcing this to a vendor. + +Some of the Serverless Cloud Providers are + +![https://serverless.com/framework/docs/providers/aws/](./etc/aws-black.png "aws") +![https://serverless.com/framework/docs/providers/azure/](./etc/azure-black.png "azure") +![https://serverless.com/framework/docs/providers/openwhisk/](./etc/openwhisk-black.png "openwhisk") +![https://serverless.com/framework/docs/providers/google/](./etc/gcf-black.png "google") +![https://serverless.com/framework/docs/providers/kubeless/](./etc/kubeless-logos-black.png "kubeless") +![https://serverless.com/framework/docs/providers/spotinst/](./etc/spotinst-logos-black-small.png "spotinst") +![https://serverless.com/framework/docs/providers/webtasks/](./etc/webtask-small-grayscale.png "webtask") +... + +Anything that triggers an Lambda Function to execute is regarded by the Framework as +an Event. Most of the Serverless Cloud Providers support following Events +- Http +- PubSub Events +- scheduled + +AWS supports processing event generated from AWS Services (S3/Cloudwatch/etc) and +using aws as a compute engine is our first choice. + +## (Backend as a Service or "BaaS") +This example creates a backend for ‘persons’ collection which uses DynamoDB NoSQL +database service also provided by Amazon. + +## AWS lambda function implementation + +[AWS Lambda SDK](https://aws.amazon.com/sdk-for-java/) provides pre-defined interface +`com.amazonaws.services.lambda.runtime +.RequestHandler` to implement our lambda function. + +```java +public class LambdaInfoApiHandler implements RequestHandler, ApiGatewayResponse> { + + private static final Logger LOG = Logger.getLogger(LambdaInfoApiHandler.class); + private static final Integer SUCCESS_STATUS_CODE = 200; + + + @Override + public ApiGatewayResponse handleRequest(Map input, Context context) { + + } +} +``` +handleRequest method is where the function code is implemented. Context provides +useful information about Lambda execution environment. AWS Lambda function needs a +deployment package. This package is either a .zip or .jar file that contains all the +dependencies of the function. + +`serverless.yml` contains configuration to manage deployments for your functions. + +## Run example in local + +# Pre-requisites + +* Node.js v6.5.0 or later. +* Serverless CLI v1.9.0 or later. You can run npm install -g serverless to install it. +* An AWS account. If you don't already have one, you can sign up for a free trial that includes 1 million free Lambda requests per month. +* [Set-up](https://serverless.com/framework/docs/providers/aws/guide/credentials/) your Provider Credentials. Watch the video on setting up credentials + +# build and deploy + +* `cd serverless` +* `mvn clean package` +* `serverless deploy --stage=dev --verbose` + +Based on the configuration in `serverless.yml` serverless framework creates following +resources + +* CloudFormation stack for S3 (ServerlessDeploymentBucket) +* IAM Role (IamRoleLambdaExecution) +* CloudWatch (log groups) +* API Gateway (ApiGatewayRestApi) +* Lambda function +* DynamoDB collection + +The command will print out Stack Outputs which looks something like this + +```yaml +endpoints: + GET - https://xxxxxxxxx.execute-api.us-east-1.amazonaws.com/dev/info + POST - https://xxxxxxxxx.execute-api.us-east-1.amazonaws.com/dev/api/person + GET - https://xxxxxxxxx.execute-api.us-east-1.amazonaws.com/dev/api/person/{id} + +``` + +```yaml +CurrentTimeLambdaFunctionQualifiedArn: arn:aws:lambda:us-east-1:xxxxxxxxxxx:function:lambda-info-http-endpoint-dev-currentTime:4 +ServiceEndpoint: https://xxxxxxxxx.execute-api.us-east-1.amazonaws.com/dev +ServerlessDeploymentBucketName: lambda-info-http-endpoin-serverlessdeploymentbuck-2u8uz2i7cap2 +``` +access the endpoint to invoke the function. + +Use the following cURL commands to test the endpoints + +```cURL +curl -X GET \ + https://xxxxxxxxx.execute-api.us-east-1.amazonaws.com/dev/info \ + -H 'cache-control: no-cache' +``` + +```cURL +curl -X POST \ + https://xxxxxxxxx.execute-api.us-east-1.amazonaws.com/dev/api/person \ + -H 'cache-control: no-cache' \ + -H 'content-type: application/json' \ + -d '{ + "firstName": "Thor", + "lastName": "Odinson", + "address": { + "addressLineOne": "1 Odin ln", + "addressLineTwo": "100", + "city": "Asgard", + "state": "country of the Gods", + "zipCode": "00001" + } +}' +``` + +```cURL +curl -X GET \ + https://xxxxxxxxx.execute-api.us-east-1.amazonaws.com/dev/api/person/{id} \ + -H 'cache-control: no-cache' +``` + +### Credits + +* [serverless docs](https://serverless.com/framework/docs/) +* [Serverless Architectures](https://martinfowler.com/articles/serverless.html) +* [Serverless Black Belt](https://youtu.be/oQFORsso2go) + + +## Service Layer +[⬆](#content) + +--- +layout: pattern +title: Service Layer +folder: service-layer +permalink: /patterns/service-layer/ +categories: Architectural +tags: + - Data access +--- + +### Intent + +Service Layer is an abstraction over domain logic. It defines application's boundary with a layer of services that +establishes a set of available operations and coordinates the application's response in each operation. + +### Explanation + +Typically applications require different kinds of interfaces to the data they store and the logic they implement. +Despite their different purposes, these interfaces often need common interactions with the application to access and +manipulate its data and invoke its business logic. Encoding the logic of the interactions separately in each module +causes a lot of duplication. It's better to centralize building the business logic inside single Service Layer to avoid +these pitfalls. + +Real world example + +> We are writing an application that tracks wizards, spellbooks and spells. Wizards may have spellbooks and spellbooks +may have spells. + +In plain words + +> Service Layer is an abstraction over application's business logic. + +Wikipedia says + +> Service layer is an architectural pattern, applied within the service-orientation design paradigm, which aims to +organize the services, within a service inventory, into a set of logical layers. Services that are categorized into +a particular layer share functionality. This helps to reduce the conceptual overhead related to managing the service +inventory, as the services belonging to the same layer address a smaller set of activities. + +**Programmatic Example** + +The example application demonstrates interactions between a client `App` and a service `MagicService` that allows +interaction between wizards, spellbooks and spells. The service is implemented with 3-layer architecture +(entity, dao, service). + +For this explanation we are looking at one vertical slice of the system. Let's start from the entity layer and look at +`Wizard` class. Other entities not shown here are `Spellbook` and `Spell`. + +```java +@Entity +@Table(name = "WIZARD") +public class Wizard extends BaseEntity { + + @Id + @GeneratedValue + @Column(name = "WIZARD_ID") + private Long id; + + private String name; + + @ManyToMany(cascade = CascadeType.ALL) + private Set spellbooks; + + public Wizard() { + spellbooks = new HashSet<>(); + } + + public Wizard(String name) { + this(); + this.name = name; + } + + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public Set getSpellbooks() { + return spellbooks; + } + + public void setSpellbooks(Set spellbooks) { + this.spellbooks = spellbooks; + } + + public void addSpellbook(Spellbook spellbook) { + spellbook.getWizards().add(this); + spellbooks.add(spellbook); + } + + @Override + public String toString() { + return name; + } +} +``` + +Above the entity layer we have DAOs. For `Wizard` the DAO layer looks as follows. + +```java +public interface WizardDao extends Dao { + + Wizard findByName(String name); +} + +public class WizardDaoImpl extends DaoBaseImpl implements WizardDao { + + @Override + public Wizard findByName(String name) { + Transaction tx = null; + Wizard result; + try (var session = getSessionFactory().openSession()) { + tx = session.beginTransaction(); + var criteria = session.createCriteria(persistentClass); + criteria.add(Restrictions.eq("name", name)); + result = (Wizard) criteria.uniqueResult(); + tx.commit(); + } catch (Exception e) { + if (tx != null) { + tx.rollback(); + } + throw e; + } + return result; + } +} +``` + +Next we can look at the Service Layer, which in our case consists of a single `MagicService`. + +```java +public interface MagicService { + + List findAllWizards(); + + List findAllSpellbooks(); + + List findAllSpells(); + + List findWizardsWithSpellbook(String name); + + List findWizardsWithSpell(String name); +} + +public class MagicServiceImpl implements MagicService { + + private final WizardDao wizardDao; + private final SpellbookDao spellbookDao; + private final SpellDao spellDao; + + public MagicServiceImpl(WizardDao wizardDao, SpellbookDao spellbookDao, SpellDao spellDao) { + this.wizardDao = wizardDao; + this.spellbookDao = spellbookDao; + this.spellDao = spellDao; + } + + @Override + public List findAllWizards() { + return wizardDao.findAll(); + } + + @Override + public List findAllSpellbooks() { + return spellbookDao.findAll(); + } + + @Override + public List findAllSpells() { + return spellDao.findAll(); + } + + @Override + public List findWizardsWithSpellbook(String name) { + var spellbook = spellbookDao.findByName(name); + return new ArrayList<>(spellbook.getWizards()); + } + + @Override + public List findWizardsWithSpell(String name) { + var spell = spellDao.findByName(name); + var spellbook = spell.getSpellbook(); + return new ArrayList<>(spellbook.getWizards()); + } +} +``` + +And finally we can show how the client `App` interacts with `MagicService` in the Service Layer. + +```java + var service = new MagicServiceImpl(wizardDao, spellbookDao, spellDao); + LOGGER.info("Enumerating all wizards"); + service.findAllWizards().stream().map(Wizard::getName).forEach(LOGGER::info); + LOGGER.info("Enumerating all spellbooks"); + service.findAllSpellbooks().stream().map(Spellbook::getName).forEach(LOGGER::info); + LOGGER.info("Enumerating all spells"); + service.findAllSpells().stream().map(Spell::getName).forEach(LOGGER::info); + LOGGER.info("Find wizards with spellbook 'Book of Idores'"); + var wizardsWithSpellbook = service.findWizardsWithSpellbook("Book of Idores"); + wizardsWithSpellbook.forEach(w -> LOGGER.info("{} has 'Book of Idores'", w.getName())); + LOGGER.info("Find wizards with spell 'Fireball'"); + var wizardsWithSpell = service.findWizardsWithSpell("Fireball"); + wizardsWithSpell.forEach(w -> LOGGER.info("{} has 'Fireball'", w.getName())); +``` + + +### Class diagram +![alt text](./etc/service-layer.png "Service Layer") + +### Applicability +Use the Service Layer pattern when + +* You want to encapsulate domain logic under API +* You need to implement multiple interfaces with common logic and data + +### Credits + +* [Martin Fowler - Service Layer](http://martinfowler.com/eaaCatalog/serviceLayer.html) +* [Patterns of Enterprise Application Architecture](https://www.amazon.com/gp/product/0321127420/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0321127420&linkCode=as2&tag=javadesignpat-20&linkId=d9f7d37b032ca6e96253562d075fcc4a) + + +## Service Locator +[⬆](#content) + +--- +layout: pattern +title: Service Locator +folder: service-locator +permalink: /patterns/service-locator/ +categories: Architectural +tags: + - Game programming + - Performance +--- + +### Intent +Encapsulate the processes involved in obtaining a service with a +strong abstraction layer. + +### Class diagram +![alt text](./etc/service-locator.png "Service Locator") + +### Applicability +The service locator pattern is applicable whenever we want +to locate/fetch various services using JNDI which, typically, is a redundant +and expensive lookup. The service Locator pattern addresses this expensive +lookup by making use of caching techniques ie. for the very first time a +particular service is requested, the service Locator looks up in JNDI, fetched +the relevant service and then finally caches this service object. Now, further +lookups of the same service via Service Locator is done in its cache which +improves the performance of application to great extent. + +## Typical Use Case + +* When network hits are expensive and time consuming +* Lookups of services are done quite frequently +* Large number of services are being used + +### Consequences + +* Violates Interface Segregation Principle (ISP) by providing pattern consumers with an access +to a number of services that they don't potentially need. +* Creates hidden dependencies that can break the clients at runtime. + +### Credits + +* [J2EE Design Patterns](https://www.amazon.com/gp/product/0596004273/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596004273&linkCode=as2&tag=javadesignpat-20&linkId=48d37c67fb3d845b802fa9b619ad8f31) + +## Sharding +[⬆](#content) + +--- +layout: pattern +title: Sharding +folder: sharding +permalink: /patterns/sharding/ +categories: Behavioral +tags: + - Performance + - Cloud distributed +--- + +### Intent +Sharding pattern means divide the data store into horizontal partitions or shards. Each shard has the same schema, but holds its own distinct subset of the data. +A shard is a data store in its own right (it can contain the data for many entities of different types), running on a server acting as a storage node. + +### Class diagram +![alt text](./etc/sharding.urm.png "Sharding pattern class diagram") + +### Applicability +This pattern offers the following benefits: + +- You can scale the system out by adding further shards running on additional storage nodes. +- A system can use off the shelf commodity hardware rather than specialized (and expensive) computers for each storage node. +- You can reduce contention and improved performance by balancing the workload across shards. +- In the cloud, shards can be located physically close to the users that will access the data. + +### Credits + +* [Sharding pattern](https://docs.microsoft.com/en-us/azure/architecture/patterns/sharding) + +## Singleton +[⬆](#content) + +--- +layout: pattern +title: Singleton +folder: singleton +permalink: /patterns/singleton/ +categories: Creational +tags: + - Gang of Four +--- + +### Intent + +Ensure a class only has one instance, and provide a global point of access to it. + + +### Explanation + +Real world example + +> There can only be one ivory tower where the wizards study their magic. The same enchanted ivory +> tower is always used by the wizards. Ivory tower here is singleton. + +In plain words + +> Ensures that only one object of a particular class is ever created. + +Wikipedia says + +> In software engineering, the singleton pattern is a software design pattern that restricts the +> instantiation of a class to one object. This is useful when exactly one object is needed to +> coordinate actions across the system. + +**Programmatic Example** + +Joshua Bloch, Effective Java 2nd Edition p.18 + +> A single-element enum type is the best way to implement a singleton + +```java +public enum EnumIvoryTower { + INSTANCE +} +``` + +Then in order to use: + +```java +var enumIvoryTower1 = EnumIvoryTower.INSTANCE; +var enumIvoryTower2 = EnumIvoryTower.INSTANCE; +assertEquals(enumIvoryTower1, enumIvoryTower2); // true +``` + +### Class diagram + +![alt text](./etc/singleton.urm.png "Singleton pattern class diagram") + +### Applicability + +Use the Singleton pattern when + +* There must be exactly one instance of a class, and it must be accessible to clients from a well-known access point +* When the sole instance should be extensible by subclassing, and clients should be able to use an extended instance without modifying their code + +## Typical Use Case + +* The logging class +* Managing a connection to a database +* File manager + +## Real world examples + +* [java.lang.Runtime#getRuntime()](http://docs.oracle.com/javase/8/docs/api/java/lang/Runtime.html#getRuntime%28%29) +* [java.awt.Desktop#getDesktop()](http://docs.oracle.com/javase/8/docs/api/java/awt/Desktop.html#getDesktop--) +* [java.lang.System#getSecurityManager()](http://docs.oracle.com/javase/8/docs/api/java/lang/System.html#getSecurityManager--) + + +### Consequences + +* Violates Single Responsibility Principle (SRP) by controlling their own creation and lifecycle. +* Encourages using a global shared instance which prevents an object and resources used by this object from being deallocated. +* Creates tightly coupled code. The clients of the Singleton become difficult to test. +* Makes it almost impossible to subclass a Singleton. + +### Credits + +* [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/gp/product/0201633612/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0201633612&linkCode=as2&tag=javadesignpat-20&linkId=675d49790ce11db99d90bde47f1aeb59) +* [Effective Java](https://www.amazon.com/gp/product/0134685997/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0134685997&linkCode=as2&tag=javadesignpat-20&linkId=4e349f4b3ff8c50123f8147c828e53eb) +* [Head First Design Patterns: A Brain-Friendly Guide](https://www.amazon.com/gp/product/0596007124/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596007124&linkCode=as2&tag=javadesignpat-20&linkId=6b8b6eea86021af6c8e3cd3fc382cb5b) +* [Refactoring to Patterns](https://www.amazon.com/gp/product/0321213351/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0321213351&linkCode=as2&tag=javadesignpat-20&linkId=2a76fcb387234bc71b1c61150b3cc3a7) + +## Spatial Partition +[⬆](#content) + +--- +layout: pattern +title: Spatial Partition +folder: spatial-partition +permalink: /patterns/spatial-partition/ +categories: Behavioral +tags: + - Performance + - Game programming +--- + +### Intent + +As explained in the book [Game Programming Patterns](http://gameprogrammingpatterns.com/spatial-partition.html) +by Bob Nystrom, spatial partition pattern helps to efficiently locate objects by storing them in a +data structure organized by their positions. + +### Explanation + +Say, you are building a war game with hundreds, or maybe even thousands of players, who are clashing +on the battle field. Each player's position is getting updated every frame. The simple way to handle +all interactions taking place on the field is to check each player's position against every other +player's position: + +```java +public void handleMeLee(Unit units[], int numUnits) { + for (var a = 0; a < numUnits - 1; a++) + { + for (var b = a + 1; b < numUnits; b++) + { + if (units[a].position() == units[b].position()) + { + handleAttack(units[a], units[b]); + } + } + } +} +``` + +This will include a lot of unnecessary checks between players which are too far apart to have any +influence on each other. The nested loops gives this operation an O(n^2) complexity, which has to be +performed every frame since many of the objects on the field may be moving each frame. The idea +behind the Spatial Partition design pattern is to enable quick location of objects using a data +structure that is organised by their positions, so when performing an operation like the one above, +every object's position need not be checked against all other objects' positions. The data structure +can be used to store moving and static objects, though in order to keep track of the moving objects, +their positions will have to be reset each time they move. This would mean having to create a new +instance of the data structure each time an object moves, which would use up additional memory. The +common data structures used for this design pattern are: + +* Grid +* Quad tree +* K-d tree +* BSP +* Boundary volume hierarchy + +In our implementation, we use the Quadtree data structure which will reduce the time complexity of +finding the objects within a certain range from O(n^2) to O(nlogn), decreasing the computations +required significantly in case of large number of objects. + +### Class diagram + +![alt text](./etc/spatial-partition.urm.png "Spatial Partition pattern class diagram") + +### Applicability + +This pattern can be used: + +* When you need to keep track of a large number of objects' positions, which are getting updated every frame. +* When it is acceptable to trade memory for speed, since creating and updating data structure will use up extra memory. + +### Credits + +* [Game Programming Patterns/Spatial Partition](http://gameprogrammingpatterns.com/spatial-partition.html) by Bob Nystrom +* [Quadtree tutorial](https://www.youtube.com/watch?v=OJxEcs0w_kE) by Daniel Schiffman + + +## Special Case +[⬆](#content) + +--- +layout: pattern +title: Special Case +folder: special-case +permalink: /patterns/special-case/ +categories: Behavioral +tags: + - Extensibility +--- + +### Intent + +Define some special cases, and encapsulates them into subclasses that provide different special behaviors. + +### Explanation + +Real world example + +> In an e-commerce system, presentation layer expects application layer to produce certain view model. +> We have a successful scenario, in which receipt view model contains actual data from the purchase, +> and a couple of failure scenarios. + +In plain words + +> Special Case pattern allows returning non-null real objects that perform special behaviors. + +In [Patterns of Enterprise Application Architecture](https://martinfowler.com/books/eaa.html) says +the difference from Null Object Pattern + +> If you’ll pardon the unresistable pun, I see Null Object as special case of Special Case. + +**Programmatic Example** + +To focus on the pattern itself, we implement DB and maintenance lock of the e-commerce system by the singleton instance. + +```java +public class Db { + private static Db instance; + private Map userName2User; + private Map user2Account; + private Map itemName2Product; + + public static Db getInstance() { + if (instance == null) { + synchronized (Db.class) { + if (instance == null) { + instance = new Db(); + instance.userName2User = new HashMap<>(); + instance.user2Account = new HashMap<>(); + instance.itemName2Product = new HashMap<>(); + } + } + } + return instance; + } + + public void seedUser(String userName, Double amount) { + User user = new User(userName); + instance.userName2User.put(userName, user); + Account account = new Account(amount); + instance.user2Account.put(user, account); + } + + public void seedItem(String itemName, Double price) { + Product item = new Product(price); + itemName2Product.put(itemName, item); + } + + public User findUserByUserName(String userName) { + if (!userName2User.containsKey(userName)) { + return null; + } + return userName2User.get(userName); + } + + public Account findAccountByUser(User user) { + if (!user2Account.containsKey(user)) { + return null; + } + return user2Account.get(user); + } + + public Product findProductByItemName(String itemName) { + if (!itemName2Product.containsKey(itemName)) { + return null; + } + return itemName2Product.get(itemName); + } + + public class User { + private String userName; + + public User(String userName) { + this.userName = userName; + } + + public String getUserName() { + return userName; + } + + public ReceiptDto purchase(Product item) { + return new ReceiptDto(item.getPrice()); + } + } + + public class Account { + private Double amount; + + public Account(Double amount) { + this.amount = amount; + } + + public MoneyTransaction withdraw(Double price) { + if (price > amount) { + return null; + } + return new MoneyTransaction(amount, price); + } + + public Double getAmount() { + return amount; + } + } + + public class Product { + private Double price; + + public Product(Double price) { + this.price = price; + } + + public Double getPrice() { + return price; + } + } +} + +public class MaintenanceLock { + private static final Logger LOGGER = LoggerFactory.getLogger(MaintenanceLock.class); + + private static MaintenanceLock instance; + private boolean lock = true; + + public static MaintenanceLock getInstance() { + if (instance == null) { + synchronized (MaintenanceLock.class) { + if (instance == null) { + instance = new MaintenanceLock(); + } + } + } + return instance; + } + + public boolean isLock() { + return lock; + } + + public void setLock(boolean lock) { + this.lock = lock; + LOGGER.info("Maintenance lock is set to: " + lock); + } +} +``` + +Let's first introduce presentation layer, the receipt view model interface and its implementation of successful scenario. + +```java +public interface ReceiptViewModel { + void show(); +} + +public class ReceiptDto implements ReceiptViewModel { + + private static final Logger LOGGER = LoggerFactory.getLogger(ReceiptDto.class); + + private Double price; + + public ReceiptDto(Double price) { + this.price = price; + } + + public Double getPrice() { + return price; + } + + @Override + public void show() { + LOGGER.info("Receipt: " + price + " paid"); + } +} +``` + +And here are the implementations of failure scenarios, which are the special cases. + +```java +public class DownForMaintenance implements ReceiptViewModel { + private static final Logger LOGGER = LoggerFactory.getLogger(DownForMaintenance.class); + + @Override + public void show() { + LOGGER.info("Down for maintenance"); + } +} + +public class InvalidUser implements ReceiptViewModel { + private static final Logger LOGGER = LoggerFactory.getLogger(InvalidUser.class); + + private final String userName; + + public InvalidUser(String userName) { + this.userName = userName; + } + + @Override + public void show() { + LOGGER.info("Invalid user: " + userName); + } +} + +public class OutOfStock implements ReceiptViewModel { + + private static final Logger LOGGER = LoggerFactory.getLogger(OutOfStock.class); + + private String userName; + private String itemName; + + public OutOfStock(String userName, String itemName) { + this.userName = userName; + this.itemName = itemName; + } + + @Override + public void show() { + LOGGER.info("Out of stock: " + itemName + " for user = " + userName + " to buy"); + } +} + +public class InsufficientFunds implements ReceiptViewModel { + private static final Logger LOGGER = LoggerFactory.getLogger(InsufficientFunds.class); + + private String userName; + private Double amount; + private String itemName; + + public InsufficientFunds(String userName, Double amount, String itemName) { + this.userName = userName; + this.amount = amount; + this.itemName = itemName; + } + + @Override + public void show() { + LOGGER.info("Insufficient funds: " + amount + " of user: " + userName + + " for buying item: " + itemName); + } +} +``` + +Second, here's the application layer, the application services implementation and the domain services implementation. + +```java +public class ApplicationServicesImpl implements ApplicationServices { + private DomainServicesImpl domain = new DomainServicesImpl(); + + @Override + public ReceiptViewModel loggedInUserPurchase(String userName, String itemName) { + if (isDownForMaintenance()) { + return new DownForMaintenance(); + } + return this.domain.purchase(userName, itemName); + } + + private boolean isDownForMaintenance() { + return MaintenanceLock.getInstance().isLock(); + } +} + +public class DomainServicesImpl implements DomainServices { + public ReceiptViewModel purchase(String userName, String itemName) { + Db.User user = Db.getInstance().findUserByUserName(userName); + if (user == null) { + return new InvalidUser(userName); + } + + Db.Account account = Db.getInstance().findAccountByUser(user); + return purchase(user, account, itemName); + } + + private ReceiptViewModel purchase(Db.User user, Db.Account account, String itemName) { + Db.Product item = Db.getInstance().findProductByItemName(itemName); + if (item == null) { + return new OutOfStock(user.getUserName(), itemName); + } + + ReceiptDto receipt = user.purchase(item); + MoneyTransaction transaction = account.withdraw(receipt.getPrice()); + if (transaction == null) { + return new InsufficientFunds(user.getUserName(), account.getAmount(), itemName); + } + + return receipt; + } +} +``` + +Finally, the client send requests the application services to get the presentation view. + +```java + // DB seeding + LOGGER.info("Db seeding: " + "1 user: {\"ignite1771\", amount = 1000.0}, " + + "2 products: {\"computer\": price = 800.0, \"car\": price = 20000.0}"); + Db.getInstance().seedUser("ignite1771", 1000.0); + Db.getInstance().seedItem("computer", 800.0); + Db.getInstance().seedItem("car", 20000.0); + + var applicationServices = new ApplicationServicesImpl(); + ReceiptViewModel receipt; + + LOGGER.info("[REQUEST] User: " + "abc123" + " buy product: " + "tv"); + receipt = applicationServices.loggedInUserPurchase("abc123", "tv"); + receipt.show(); + MaintenanceLock.getInstance().setLock(false); + LOGGER.info("[REQUEST] User: " + "abc123" + " buy product: " + "tv"); + receipt = applicationServices.loggedInUserPurchase("abc123", "tv"); + receipt.show(); + LOGGER.info("[REQUEST] User: " + "ignite1771" + " buy product: " + "tv"); + receipt = applicationServices.loggedInUserPurchase("ignite1771", "tv"); + receipt.show(); + LOGGER.info("[REQUEST] User: " + "ignite1771" + " buy product: " + "car"); + receipt = applicationServices.loggedInUserPurchase("ignite1771", "car"); + receipt.show(); + LOGGER.info("[REQUEST] User: " + "ignite1771" + " buy product: " + "computer"); + receipt = applicationServices.loggedInUserPurchase("ignite1771", "computer"); + receipt.show(); +``` + +Program output of every request: + +``` + Down for maintenance + Invalid user: abc123 + Out of stock: tv for user = ignite1771 to buy + Insufficient funds: 1000.0 of user: ignite1771 for buying item: car + Receipt: 800.0 paid +``` + +### Class diagram + +![alt text](./etc/special_case_urm.png "Special Case") + +### Applicability + +Use the Special Case pattern when + +* You have multiple places in the system that have the same behavior after a conditional check +for a particular class instance, or the same behavior after a null check. +* Return a real object that performs the real behavior, instead of a null object that performs nothing. + +### Tutorial + +* [Special Case Tutorial](https://www.codinghelmet.com/articles/reduce-cyclomatic-complexity-special-case) + +### Credits + +* [How to Reduce Cyclomatic Complexity Part 2: Special Case Pattern](https://www.codinghelmet.com/articles/reduce-cyclomatic-complexity-special-case) +* [Patterns of Enterprise Application Architecture](https://martinfowler.com/books/eaa.html) +* [Special Case](https://www.martinfowler.com/eaaCatalog/specialCase.html)--- + + +## Specification +[⬆](#content) + +--- +layout: pattern +title: Specification +folder: specification +permalink: /patterns/specification/ +categories: Behavioral +tags: + - Data access +--- + +### Also known as + +Filter, Criteria + +### Intent + +Specification pattern separates the statement of how to match a candidate, from the candidate object +that it is matched against. As well as its usefulness in selection, it is also valuable for +validation and for building to order. + +### Explanation + +Real world example + +> There is a pool of different creatures and we often need to select some subset of them. We can +> write our search specification such as "creatures that can fly", "creatures heavier than 500 +> kilograms", or as a combination of other search specifications, and then give it to the party that +> will perform the filtering. + +In Plain Words + +> Specification pattern allows us to separate the search criteria from the object that performs the +> search. + +Wikipedia says + +> In computer programming, the specification pattern is a particular software design pattern, +> whereby business rules can be recombined by chaining the business rules together using boolean +> logic. + +**Programmatic Example** + +If we look at our creature pool example from above, we have a set of creatures with certain +properties. Those properties can be part of a pre-defined, limited set (represented here by the +enums Size, Movement and Color); but they can also be continuous values (e.g. the mass of a +Creature). In this case, it is more appropriate to use what we call "parameterized specification", +where the property value can be given as an argument when the Creature is instantiated, allowing for +more flexibility. A third option is to combine pre-defined and/or parameterized properties using +boolean logic, allowing for near-endless selection possibilities (this is called "composite +specification", see below). The pros and cons of each approach are detailed in the table at the end +of this document. + +```java +public interface Creature { + String getName(); + Size getSize(); + Movement getMovement(); + Color getColor(); + Mass getMass(); +} +``` + +And `Dragon` implementation looks like this. + +```java +public class Dragon extends AbstractCreature { + + public Dragon() { + super("Dragon", Size.LARGE, Movement.FLYING, Color.RED, new Mass(39300.0)); + } +} +``` + +Now that we want to select some subset of them, we use selectors. To select creatures that fly, we +should use `MovementSelector`. + +```java +public class MovementSelector extends AbstractSelector { + + private final Movement movement; + + public MovementSelector(Movement m) { + this.movement = m; + } + + @Override + public boolean test(Creature t) { + return t.getMovement().equals(movement); + } +} +``` + +On the other hand, when selecting creatures heavier than a chosen amount, we use +`MassGreaterThanSelector`. + +```java +public class MassGreaterThanSelector extends AbstractSelector { + + private final Mass mass; + + public MassGreaterThanSelector(double mass) { + this.mass = new Mass(mass); + } + + @Override + public boolean test(Creature t) { + return t.getMass().greaterThan(mass); + } +} +``` + +With these building blocks in place, we can perform a search for red creatures as follows: + +```java + var redCreatures = creatures.stream().filter(new ColorSelector(Color.RED)) + .collect(Collectors.toList()); +``` + +But we could also use our parameterized selector like this: + +```java + var heavyCreatures = creatures.stream().filter(new MassGreaterThanSelector(500.0) + .collect(Collectors.toList()); +``` + +Our third option is to combine multiple selectors together. Performing a search for special +creatures (defined as red, flying, and not small) could be done as follows: + +```java + var specialCreaturesSelector = + new ColorSelector(Color.RED).and(new MovementSelector(Movement.FLYING)).and(new SizeSelector(Size.SMALL).not()); + + var specialCreatures = creatures.stream().filter(specialCreaturesSelector) + .collect(Collectors.toList()); +``` + +**More on Composite Specification** + +In Composite Specification, we will create custom instances of `AbstractSelector` by combining +other selectors (called "leaves") using the three basic logical operators. These are implemented in +`ConjunctionSelector`, `DisjunctionSelector` and `NegationSelector`. + +```java +public abstract class AbstractSelector implements Predicate { + + public AbstractSelector and(AbstractSelector other) { + return new ConjunctionSelector<>(this, other); + } + + public AbstractSelector or(AbstractSelector other) { + return new DisjunctionSelector<>(this, other); + } + + public AbstractSelector not() { + return new NegationSelector<>(this); + } +} +``` + +```java +public class ConjunctionSelector extends AbstractSelector { + + private final List> leafComponents; + + @SafeVarargs + ConjunctionSelector(AbstractSelector... selectors) { + this.leafComponents = List.of(selectors); + } + + /** + * Tests if *all* selectors pass the test. + */ + @Override + public boolean test(T t) { + return leafComponents.stream().allMatch(comp -> (comp.test(t))); + } +} +``` + +All that is left to do is now to create leaf selectors (be it hard-coded or parameterized ones) that +are as generic as possible, and we will be able to instantiate the ``AbstractSelector`` class by +combining any amount of selectors, as exemplified above. We should be careful though, as it is easy +to make a mistake when combining many logical operators; in particular, we should pay attention to +the priority of the operations. In general, Composite Specification is a great way to write more +reusable code, as there is no need to create a Selector class for each filtering operation. Instead, +we just create an instance of ``AbstractSelector`` "on the spot", using tour generic "leaf" +selectors and some basic boolean logic. + +**Comparison of the different approaches** + +| Pattern | Usage | Pros | Cons | +|---|---|---|---| +| Hard-Coded Specification | Selection criteria are few and known in advance | + Easy to implement | - Inflexible | +| | | + Expressive | +| Parameterized Specification | Selection criteria are a large range of values (e.g. mass, speed,...) | + Some flexibility | - Still requires special-purpose classes | +| Composite Specification | There are a lot of selection criteria that can be combined in multiple ways, hence it is not feasible to create a class for each selector | + Very flexible, without requiring many specialized classes | - Somewhat more difficult to comprehend | +| | | + Supports logical operations | - You still need to create the base classes used as leaves | + +### Class diagram + +![alt text](./etc/specification.png "Specification") + +### Applicability + +Use the Specification pattern when + +* You need to select a subset of objects based on some criteria, and to refresh the selection at various times. +* You need to check that only suitable objects are used for a certain role (validation). + +### Related patterns + +* Repository + +### Credits + +* [Martin Fowler - Specifications](http://martinfowler.com/apsupp/spec.pdf) + + +## State +[⬆](#content) + +--- +layout: pattern +title: State +folder: state +permalink: /patterns/state/ +categories: Behavioral +tags: + - Gang of Four +--- + +### Also known as + +Objects for States + +### Intent + +Allow an object to alter its behavior when its internal state changes. The object will appear to +change its class. + +### Explanation + +Real world example + +> When observing a mammoth in its natural habitat it seems to change its behavior based on the +> situation. It may first appear calm but over time when it detects a threat it gets angry and +> dangerous to its surroundings. + +In plain words + +> State pattern allows an object to change its behavior. + +Wikipedia says + +> The state pattern is a behavioral software design pattern that allows an object to alter its +> behavior when its internal state changes. This pattern is close to the concept of finite-state +> machines. The state pattern can be interpreted as a strategy pattern, which is able to switch a +> strategy through invocations of methods defined in the pattern's interface. + +**Programmatic Example** + +Here is the state interface and its concrete implementations. + +```java +public interface State { + + void onEnterState(); + + void observe(); +} + +public class PeacefulState implements State { + + private static final Logger LOGGER = LoggerFactory.getLogger(PeacefulState.class); + + private final Mammoth mammoth; + + public PeacefulState(Mammoth mammoth) { + this.mammoth = mammoth; + } + + @Override + public void observe() { + LOGGER.info("{} is calm and peaceful.", mammoth); + } + + @Override + public void onEnterState() { + LOGGER.info("{} calms down.", mammoth); + } +} + +public class AngryState implements State { + + private static final Logger LOGGER = LoggerFactory.getLogger(AngryState.class); + + private final Mammoth mammoth; + + public AngryState(Mammoth mammoth) { + this.mammoth = mammoth; + } + + @Override + public void observe() { + LOGGER.info("{} is furious!", mammoth); + } + + @Override + public void onEnterState() { + LOGGER.info("{} gets angry!", mammoth); + } +} +``` + +And here is the mammoth containing the state. + +```java +public class Mammoth { + + private State state; + + public Mammoth() { + state = new PeacefulState(this); + } + + public void timePasses() { + if (state.getClass().equals(PeacefulState.class)) { + changeStateTo(new AngryState(this)); + } else { + changeStateTo(new PeacefulState(this)); + } + } + + private void changeStateTo(State newState) { + this.state = newState; + this.state.onEnterState(); + } + + @Override + public String toString() { + return "The mammoth"; + } + + public void observe() { + this.state.observe(); + } +} +``` + +And here is the full example how the mammoth behaves over time. + +```java + var mammoth = new Mammoth(); + mammoth.observe(); + mammoth.timePasses(); + mammoth.observe(); + mammoth.timePasses(); + mammoth.observe(); +``` + +Program output: + +```java + The mammoth gets angry! + The mammoth is furious! + The mammoth calms down. + The mammoth is calm and peaceful. +``` + +### Class diagram + +![alt text](./etc/state_urm.png "State") + +### Applicability + +Use the State pattern in either of the following cases + +* An object's behavior depends on its state, and it must change its behavior at run-time depending on that state +* Operations have large, multipart conditional statements that depend on the object's state. This state is usually represented by one or more enumerated constants. Often, several operations will contain this same conditional structure. The State pattern puts each branch of the conditional in a separate class. This lets you treat the object's state as an object in its own right that can vary independently from other objects. + +## Real world examples + +* [javax.faces.lifecycle.Lifecycle#execute()](http://docs.oracle.com/javaee/7/api/javax/faces/lifecycle/Lifecycle.html#execute-javax.faces.context.FacesContext-) controlled by [FacesServlet](http://docs.oracle.com/javaee/7/api/javax/faces/webapp/FacesServlet.html), the behavior is dependent on current phase of lifecycle. +* [JDiameter - Diameter State Machine](https://github.com/npathai/jdiameter/blob/master/core/jdiameter/api/src/main/java/org/jdiameter/api/app/State.java) + +### Credits + +* [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/gp/product/0201633612/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0201633612&linkCode=as2&tag=javadesignpat-20&linkId=675d49790ce11db99d90bde47f1aeb59) +* [Head First Design Patterns: A Brain-Friendly Guide](https://www.amazon.com/gp/product/0596007124/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596007124&linkCode=as2&tag=javadesignpat-20&linkId=6b8b6eea86021af6c8e3cd3fc382cb5b) +* [Refactoring to Patterns](https://www.amazon.com/gp/product/0321213351/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0321213351&linkCode=as2&tag=javadesignpat-20&linkId=2a76fcb387234bc71b1c61150b3cc3a7) + + +## Step Builder +[⬆](#content) + +--- +layout: pattern +title: Step Builder +folder: step-builder +permalink: /patterns/step-builder/ +categories: Creational +tags: + - Instantiation +--- + +### Intent +An extension of the Builder pattern that fully guides the user through the creation of the object with no chances of confusion. +The user experience will be much more improved by the fact that he will only see the next step methods available, NO build method until is the right time to build the object. + +### Class diagram +![alt text](./etc/step-builder.png "Step Builder") + +### Applicability +Use the Step Builder pattern when the algorithm for creating a complex object should be independent of the parts that make up the object and how they're assembled the construction process must allow different representations for the object that's constructed when in the process of constructing the order is important. + +### Credits + +* [Marco Castigliego - Step Builder](http://rdafbn.blogspot.co.uk/2012/07/step-builder-pattern_28.html) + +## Strangler +[⬆](#content) + +--- +layout: pattern +title: Strangler +folder: strangler +permalink: /patterns/strangler/ +categories: Structural +tags: + - Extensibility + - Cloud distributed +--- + +### Intent +Incrementally migrate a legacy system by gradually replacing specific pieces of functionality +with new applications and services. As features from the legacy system are replaced, the new +system eventually covers all the old system's features and may has its own new features, then +strangling the old system and allowing you to decommission it. + +### Class diagram +![alt text](./etc/strangler.png "Strangler") + +### Applicability +This strangler pattern is a safe way to phase one thing out for something better, cheaper, or +more expandable. Especially when you want to update legacy system with new techniques and need +continuously develop new features at the same time. Note that this pattern indeed need extra effort, +so usually use it when the system is not so simple. + +### Credits + +* [Strangler pattern](https://docs.microsoft.com/en-us/azure/architecture/patterns/strangler) +* [Legacy Application Strangulation : Case Studies](https://paulhammant.com/2013/07/14/legacy-application-strangulation-case-studies/) + +## Strategy +[⬆](#content) + +--- +layout: pattern +title: Strategy +folder: strategy +permalink: /patterns/strategy/ +categories: Behavioral +tags: + - Gang of Four +--- + +### Also known as + +Policy + +### Intent + +Define a family of algorithms, encapsulate each one, and make them interchangeable. Strategy lets +the algorithm vary independently from clients that use it. + +### Explanation + +Real world example + +> Slaying dragons is a dangerous job. With experience it becomes easier. Veteran +> dragonslayers have developed different fighting strategies against different types of dragons. + +In plain words + +> Strategy pattern allows choosing the best suited algorithm at runtime. + +Wikipedia says + +> In computer programming, the strategy pattern (also known as the policy pattern) is a behavioral +> software design pattern that enables selecting an algorithm at runtime. + +**Programmatic Example** + +Let's first introduce the dragon slaying strategy interface and its implementations. + +```java +@FunctionalInterface +public interface DragonSlayingStrategy { + + void execute(); +} + +public class MeleeStrategy implements DragonSlayingStrategy { + + private static final Logger LOGGER = LoggerFactory.getLogger(MeleeStrategy.class); + + @Override + public void execute() { + LOGGER.info("With your Excalibur you sever the dragon's head!"); + } +} + +public class ProjectileStrategy implements DragonSlayingStrategy { + + private static final Logger LOGGER = LoggerFactory.getLogger(ProjectileStrategy.class); + + @Override + public void execute() { + LOGGER.info("You shoot the dragon with the magical crossbow and it falls dead on the ground!"); + } +} + +public class SpellStrategy implements DragonSlayingStrategy { + + private static final Logger LOGGER = LoggerFactory.getLogger(SpellStrategy.class); + + @Override + public void execute() { + LOGGER.info("You cast the spell of disintegration and the dragon vaporizes in a pile of dust!"); + } +} +``` + +And here is the mighty dragonslayer, who is able to pick his fighting strategy based on the +opponent. + +```java +public class DragonSlayer { + + private DragonSlayingStrategy strategy; + + public DragonSlayer(DragonSlayingStrategy strategy) { + this.strategy = strategy; + } + + public void changeStrategy(DragonSlayingStrategy strategy) { + this.strategy = strategy; + } + + public void goToBattle() { + strategy.execute(); + } +} +``` + +Finally here's the dragonslayer in action. + +```java + LOGGER.info("Green dragon spotted ahead!"); + var dragonSlayer = new DragonSlayer(new MeleeStrategy()); + dragonSlayer.goToBattle(); + LOGGER.info("Red dragon emerges."); + dragonSlayer.changeStrategy(new ProjectileStrategy()); + dragonSlayer.goToBattle(); + LOGGER.info("Black dragon lands before you."); + dragonSlayer.changeStrategy(new SpellStrategy()); + dragonSlayer.goToBattle(); +``` + +Program output: + +``` + Green dragon spotted ahead! + With your Excalibur you sever the dragon's head! + Red dragon emerges. + You shoot the dragon with the magical crossbow and it falls dead on the ground! + Black dragon lands before you. + You cast the spell of disintegration and the dragon vaporizes in a pile of dust! +``` + +What's more, the new feature Lambda Expressions in Java 8 provides another approach for the implementation: + +```java +public class LambdaStrategy { + + private static final Logger LOGGER = LoggerFactory.getLogger(LambdaStrategy.class); + + public enum Strategy implements DragonSlayingStrategy { + MeleeStrategy(() -> LOGGER.info( + "With your Excalibur you severe the dragon's head!")), + ProjectileStrategy(() -> LOGGER.info( + "You shoot the dragon with the magical crossbow and it falls dead on the ground!")), + SpellStrategy(() -> LOGGER.info( + "You cast the spell of disintegration and the dragon vaporizes in a pile of dust!")); + + private final DragonSlayingStrategy dragonSlayingStrategy; + + Strategy(DragonSlayingStrategy dragonSlayingStrategy) { + this.dragonSlayingStrategy = dragonSlayingStrategy; + } + + @Override + public void execute() { + dragonSlayingStrategy.execute(); + } + } +} +``` + +And here's the dragonslayer in action. + +```java + LOGGER.info("Green dragon spotted ahead!"); + dragonSlayer.changeStrategy(LambdaStrategy.Strategy.MeleeStrategy); + dragonSlayer.goToBattle(); + LOGGER.info("Red dragon emerges."); + dragonSlayer.changeStrategy(LambdaStrategy.Strategy.ProjectileStrategy); + dragonSlayer.goToBattle(); + LOGGER.info("Black dragon lands before you."); + dragonSlayer.changeStrategy(LambdaStrategy.Strategy.SpellStrategy); + dragonSlayer.goToBattle(); +``` + +Program output is the same as above one. + +### Class diagram + +![alt text](./etc/strategy_urm.png "Strategy") + +### Applicability + +Use the Strategy pattern when + +* Many related classes differ only in their behavior. Strategies provide a way to configure a class either one of many behaviors +* You need different variants of an algorithm. for example, you might define algorithms reflecting different space/time trade-offs. Strategies can be used when these variants are implemented as a class hierarchy of algorithms +* An algorithm uses data that clients shouldn't know about. Use the Strategy pattern to avoid exposing complex, algorithm-specific data structures +* A class defines many behaviors, and these appear as multiple conditional statements in its operations. Instead of many conditionals, move related conditional branches into their own Strategy class + +### Tutorial + +* [Strategy Pattern Tutorial](https://www.journaldev.com/1754/strategy-design-pattern-in-java-example-tutorial) + +### Credits + +* [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/gp/product/0201633612/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0201633612&linkCode=as2&tag=javadesignpat-20&linkId=675d49790ce11db99d90bde47f1aeb59) +* [Functional Programming in Java: Harnessing the Power of Java 8 Lambda Expressions](https://www.amazon.com/gp/product/1937785467/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1937785467&linkCode=as2&tag=javadesignpat-20&linkId=7e4e2fb7a141631491534255252fd08b) +* [Head First Design Patterns: A Brain-Friendly Guide](https://www.amazon.com/gp/product/0596007124/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596007124&linkCode=as2&tag=javadesignpat-20&linkId=6b8b6eea86021af6c8e3cd3fc382cb5b) +* [Refactoring to Patterns](https://www.amazon.com/gp/product/0321213351/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0321213351&linkCode=as2&tag=javadesignpat-20&linkId=2a76fcb387234bc71b1c61150b3cc3a7) + +## Subclass Sandbox +[⬆](#content) + +--- +layout: pattern +title: Subclass Sandbox +folder: subclass-sandbox +permalink: /patterns/subclass-sandbox/ +categories: Behavioral +tags: + - Game programming +--- + +### Intent +The subclass sandbox pattern describes a basic idea, while not having a lot of detailed mechanics. You will need the pattern when you have several similar subclasses. If you have to make a tiny change, then change the base class, while all subclasses shouldn't have to be touched. So the base class has to be able to provide all of the operations a derived class needs to perform. + +### Class diagram +![alt text](./etc/subclass-sandbox.urm.png "Subclass Sandbox pattern class diagram") + +### Applicability +The Subclass Sandbox pattern is a very simple, common pattern lurking in lots of codebases, even outside of games. If you have a non-virtual protected method laying around, you’re probably already using something like this. Subclass Sandbox is a good fit when: + +- You have a base class with a number of derived classes. +- The base class is able to provide all of the operations that a derived class may need to perform. +- There is behavioral overlap in the subclasses and you want to make it easier to share code between them. +- You want to minimize coupling between those derived classes and the rest of the program. + +### Credits + +* [Game Programming Patterns - Subclass Sandbox]([http://gameprogrammingpatterns.com/subclass-sandbox.html](http://gameprogrammingpatterns.com/subclass-sandbox.html)) + + +## Template Method +[⬆](#content) + +--- +layout: pattern +title: Template method +folder: template-method +permalink: /patterns/template-method/ +categories: Behavioral +tags: + - Gang of Four +--- + +### Intent + +Define the skeleton of an algorithm in an operation, deferring some steps to subclasses. Template +Method lets subclasses redefine certain steps of an algorithm without changing the algorithm's +structure. + +### Explanation + +Real world example + +> The general steps in stealing an item are the same. First you pick the target, next you confuse +> him somehow and finally you steal the item. However there are many ways to implement these steps. + +In plain words + +> Template Method pattern outlines the general steps in the parent class and lets the concrete child +> implementations define the details. + +Wikipedia says + +> In object-oriented programming, the template method is one of the behavioral design patterns +> identified by Gamma et al. in the book Design Patterns. The template method is a method in a +> superclass, usually an abstract superclass, and defines the skeleton of an operation in terms of +> a number of high-level steps. These steps are themselves implemented by additional helper methods +> in the same class as the template method. + +**Programmatic Example** + +Let's first introduce the template method class along with its concrete implementations. + +```java +public abstract class StealingMethod { + + private static final Logger LOGGER = LoggerFactory.getLogger(StealingMethod.class); + + protected abstract String pickTarget(); + + protected abstract void confuseTarget(String target); + + protected abstract void stealTheItem(String target); + + public void steal() { + var target = pickTarget(); + LOGGER.info("The target has been chosen as {}.", target); + confuseTarget(target); + stealTheItem(target); + } +} + +public class SubtleMethod extends StealingMethod { + + private static final Logger LOGGER = LoggerFactory.getLogger(SubtleMethod.class); + + @Override + protected String pickTarget() { + return "shop keeper"; + } + + @Override + protected void confuseTarget(String target) { + LOGGER.info("Approach the {} with tears running and hug him!", target); + } + + @Override + protected void stealTheItem(String target) { + LOGGER.info("While in close contact grab the {}'s wallet.", target); + } +} + +public class HitAndRunMethod extends StealingMethod { + + private static final Logger LOGGER = LoggerFactory.getLogger(HitAndRunMethod.class); + + @Override + protected String pickTarget() { + return "old goblin woman"; + } + + @Override + protected void confuseTarget(String target) { + LOGGER.info("Approach the {} from behind.", target); + } + + @Override + protected void stealTheItem(String target) { + LOGGER.info("Grab the handbag and run away fast!"); + } +} +``` + +Here's the halfling thief class containing the template method. + +```java +public class HalflingThief { + + private StealingMethod method; + + public HalflingThief(StealingMethod method) { + this.method = method; + } + + public void steal() { + method.steal(); + } + + public void changeMethod(StealingMethod method) { + this.method = method; + } +} +``` + +And finally we show how the halfling thief utilizes the different stealing methods. + +```java + var thief = new HalflingThief(new HitAndRunMethod()); + thief.steal(); + thief.changeMethod(new SubtleMethod()); + thief.steal(); +``` + +### Class diagram + +![alt text](./etc/template_method_urm.png "Template Method") + +### Applicability + +The Template Method pattern should be used + +* To implement the invariant parts of an algorithm once and leave it up to subclasses to implement the behavior that can vary +* When common behavior among subclasses should be factored and localized in a common class to avoid code duplication. This is good example of "refactoring to generalize" as described by Opdyke and Johnson. You first identify the differences in the existing code and then separate the differences into new operations. Finally, you replace the differing code with a template method that calls one of these new operations +* To control subclasses extensions. You can define a template method that calls "hook" operations at specific points, thereby permitting extensions only at those points + +### Tutorial + +* [Template-method Pattern Tutorial](https://www.journaldev.com/1763/template-method-design-pattern-in-java) + +## Real world examples + +* [javax.servlet.GenericServlet.init](https://jakarta.ee/specifications/servlet/4.0/apidocs/javax/servlet/GenericServlet.html#init--): +Method `GenericServlet.init(ServletConfig config)` calls the parameterless method `GenericServlet.init()` which is intended to be overridden in subclasses. +Method `GenericServlet.init(ServletConfig config)` is the template method in this example. + +### Credits + +* [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/gp/product/0201633612/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0201633612&linkCode=as2&tag=javadesignpat-20&linkId=675d49790ce11db99d90bde47f1aeb59) +* [Head First Design Patterns: A Brain-Friendly Guide](https://www.amazon.com/gp/product/0596007124/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596007124&linkCode=as2&tag=javadesignpat-20&linkId=6b8b6eea86021af6c8e3cd3fc382cb5b) +* [Refactoring to Patterns](https://www.amazon.com/gp/product/0321213351/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0321213351&linkCode=as2&tag=javadesignpat-20&linkId=2a76fcb387234bc71b1c61150b3cc3a7) + +## Thread Pool +[⬆](#content) + +--- +layout: pattern +title: Thread Pool +folder: thread-pool +permalink: /patterns/thread-pool/ +categories: Concurrency +tags: + - Performance +--- + +### Intent + +It is often the case that tasks to be executed are short-lived and the number of tasks is large. +Creating a new thread for each task would make the system spend more time creating and destroying +the threads than executing the actual tasks. Thread Pool solves this problem by reusing existing +threads and eliminating the latency of creating new threads. + +### Explanation + +Real world example + +> We have a large number of relatively short tasks at hand. We need to peel huge amounts of potatoes +> and serve mighty amount of coffee cups. Creating a new thread for each task would be a waste so we +> establish a thread pool. + +In plain words + +> Thread Pool is a concurrency pattern where threads are allocated once and reused between tasks. + +Wikipedia says + +> In computer programming, a thread pool is a software design pattern for achieving concurrency of +> execution in a computer program. Often also called a replicated workers or worker-crew model, +> a thread pool maintains multiple threads waiting for tasks to be allocated for concurrent +> execution by the supervising program. By maintaining a pool of threads, the model increases +> performance and avoids latency in execution due to frequent creation and destruction of threads +> for short-lived tasks. The number of available threads is tuned to the computing resources +> available to the program, such as a parallel task queue after completion of execution. + +**Programmatic Example** + +Let's first look at our task hierarchy. We have a base class and then concrete `CoffeeMakingTask` +and `PotatoPeelingTask`. + +```java +public abstract class Task { + + private static final AtomicInteger ID_GENERATOR = new AtomicInteger(); + + private final int id; + private final int timeMs; + + public Task(final int timeMs) { + this.id = ID_GENERATOR.incrementAndGet(); + this.timeMs = timeMs; + } + + public int getId() { + return id; + } + + public int getTimeMs() { + return timeMs; + } + + @Override + public String toString() { + return String.format("id=%d timeMs=%d", id, timeMs); + } +} + +public class CoffeeMakingTask extends Task { + + private static final int TIME_PER_CUP = 100; + + public CoffeeMakingTask(int numCups) { + super(numCups * TIME_PER_CUP); + } + + @Override + public String toString() { + return String.format("%s %s", this.getClass().getSimpleName(), super.toString()); + } +} + +public class PotatoPeelingTask extends Task { + + private static final int TIME_PER_POTATO = 200; + + public PotatoPeelingTask(int numPotatoes) { + super(numPotatoes * TIME_PER_POTATO); + } + + @Override + public String toString() { + return String.format("%s %s", this.getClass().getSimpleName(), super.toString()); + } +} +``` + +Next we present a runnable `Worker` class that the thread pool will utilize to handle all the potato +peeling and coffee making. + +```java +public class Worker implements Runnable { + + private static final Logger LOGGER = LoggerFactory.getLogger(Worker.class); + + private final Task task; + + public Worker(final Task task) { + this.task = task; + } + + @Override + public void run() { + LOGGER.info("{} processing {}", Thread.currentThread().getName(), task.toString()); + try { + Thread.sleep(task.getTimeMs()); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } +} +``` + +Now we are ready to show the full example in action. + +```java + LOGGER.info("Program started"); + + // Create a list of tasks to be executed + var tasks = List.of( + new PotatoPeelingTask(3), + new PotatoPeelingTask(6), + new CoffeeMakingTask(2), + new CoffeeMakingTask(6), + new PotatoPeelingTask(4), + new CoffeeMakingTask(2), + new PotatoPeelingTask(4), + new CoffeeMakingTask(9), + new PotatoPeelingTask(3), + new CoffeeMakingTask(2), + new PotatoPeelingTask(4), + new CoffeeMakingTask(2), + new CoffeeMakingTask(7), + new PotatoPeelingTask(4), + new PotatoPeelingTask(5)); + + // Creates a thread pool that reuses a fixed number of threads operating off a shared + // unbounded queue. At any point, at most nThreads threads will be active processing + // tasks. If additional tasks are submitted when all threads are active, they will wait + // in the queue until a thread is available. + var executor = Executors.newFixedThreadPool(3); + + // Allocate new worker for each task + // The worker is executed when a thread becomes + // available in the thread pool + tasks.stream().map(Worker::new).forEach(executor::execute); + // All tasks were executed, now shutdown + executor.shutdown(); + while (!executor.isTerminated()) { + Thread.yield(); + } + LOGGER.info("Program finished"); +``` + +### Class diagram + +![alt text](./etc/thread_pool_urm.png "Thread Pool") + +### Applicability + +Use the Thread Pool pattern when + +* You have a large number of short-lived tasks to be executed in parallel + +### Credits + +* [Effective Java](https://www.amazon.com/gp/product/0134685997/ref=as_li_qf_asin_il_tl?ie=UTF8&tag=javadesignpat-20&creative=9325&linkCode=as2&creativeASIN=0134685997&linkId=e1b9ddd5e669591642c4f30d40cd9f6b) +* [Java Concurrency in Practice](https://www.amazon.com/gp/product/0321349601/ref=as_li_qf_asin_il_tl?ie=UTF8&tag=javadesignpat-20&creative=9325&linkCode=as2&creativeASIN=0321349601&linkId=fbedb3bad3c6cbead5afa56eea39ed59) + +## Throttling +[⬆](#content) + +--- +layout: pattern +title: Throttling +folder: throttling +permalink: /patterns/throttling/ +categories: Behavioral +tags: + - Performance + - Cloud distributed +--- + +### Intent + +Ensure that a given client is not able to access service resources more than the assigned limit. + +### Explanation + +Real world example + +> A large multinational corporation offers API to its customers. The API is rate-limited and each +> customer can only make certain amount of calls per second. + +In plain words + +> Throttling pattern is used to rate-limit access to a resource. + +[Microsoft documentation](https://docs.microsoft.com/en-us/azure/architecture/patterns/throttling) says + +> Control the consumption of resources used by an instance of an application, an individual tenant, +> or an entire service. This can allow the system to continue to function and meet service level +> agreements, even when an increase in demand places an extreme load on resources. + +**Programmatic Example** + +Tenant class presents the clients of the API. CallsCount tracks the number of API calls per tenant. + +```java +public class Tenant { + + private final String name; + private final int allowedCallsPerSecond; + + public Tenant(String name, int allowedCallsPerSecond, CallsCount callsCount) { + if (allowedCallsPerSecond < 0) { + throw new InvalidParameterException("Number of calls less than 0 not allowed"); + } + this.name = name; + this.allowedCallsPerSecond = allowedCallsPerSecond; + callsCount.addTenant(name); + } + + public String getName() { + return name; + } + + public int getAllowedCallsPerSecond() { + return allowedCallsPerSecond; + } +} + +public final class CallsCount { + + private static final Logger LOGGER = LoggerFactory.getLogger(CallsCount.class); + private final Map tenantCallsCount = new ConcurrentHashMap<>(); + + public void addTenant(String tenantName) { + tenantCallsCount.putIfAbsent(tenantName, new AtomicLong(0)); + } + + public void incrementCount(String tenantName) { + tenantCallsCount.get(tenantName).incrementAndGet(); + } + + public long getCount(String tenantName) { + return tenantCallsCount.get(tenantName).get(); + } + + public void reset() { + LOGGER.debug("Resetting the map."); + tenantCallsCount.replaceAll((k, v) -> new AtomicLong(0)); + } +} +``` + +Next we introduce the service that the tenants are calling. To track the call count we use the +throttler timer. + +```java +public interface Throttler { + + void start(); +} + +public class ThrottleTimerImpl implements Throttler { + + private final int throttlePeriod; + private final CallsCount callsCount; + + public ThrottleTimerImpl(int throttlePeriod, CallsCount callsCount) { + this.throttlePeriod = throttlePeriod; + this.callsCount = callsCount; + } + + @Override + public void start() { + new Timer(true).schedule(new TimerTask() { + @Override + public void run() { + callsCount.reset(); + } + }, 0, throttlePeriod); + } +} + +class B2BService { + + private static final Logger LOGGER = LoggerFactory.getLogger(B2BService.class); + private final CallsCount callsCount; + + public B2BService(Throttler timer, CallsCount callsCount) { + this.callsCount = callsCount; + timer.start(); + } + + public int dummyCustomerApi(Tenant tenant) { + var tenantName = tenant.getName(); + var count = callsCount.getCount(tenantName); + LOGGER.debug("Counter for {} : {} ", tenant.getName(), count); + if (count >= tenant.getAllowedCallsPerSecond()) { + LOGGER.error("API access per second limit reached for: {}", tenantName); + return -1; + } + callsCount.incrementCount(tenantName); + return getRandomCustomerId(); + } + + private int getRandomCustomerId() { + return ThreadLocalRandom.current().nextInt(1, 10000); + } +} +``` + +Now we are ready to see the full example in action. Tenant Adidas is rate-limited to 5 calls per +second and Nike to 6. + +```java + public static void main(String[] args) { + var callsCount = new CallsCount(); + var adidas = new Tenant("Adidas", 5, callsCount); + var nike = new Tenant("Nike", 6, callsCount); + + var executorService = Executors.newFixedThreadPool(2); + executorService.execute(() -> makeServiceCalls(adidas, callsCount)); + executorService.execute(() -> makeServiceCalls(nike, callsCount)); + executorService.shutdown(); + + try { + executorService.awaitTermination(10, TimeUnit.SECONDS); + } catch (InterruptedException e) { + LOGGER.error("Executor Service terminated: {}", e.getMessage()); + } + } + + private static void makeServiceCalls(Tenant tenant, CallsCount callsCount) { + var timer = new ThrottleTimerImpl(10, callsCount); + var service = new B2BService(timer, callsCount); + // Sleep is introduced to keep the output in check and easy to view and analyze the results. + IntStream.range(0, 20).forEach(i -> { + service.dummyCustomerApi(tenant); + try { + Thread.sleep(1); + } catch (InterruptedException e) { + LOGGER.error("Thread interrupted: {}", e.getMessage()); + } + }); + } +``` + + +### Class diagram + +![alt text](./etc/throttling_urm.png "Throttling pattern class diagram") + +### Applicability + +The Throttling pattern should be used: + +* When a service access needs to be restricted to not have high impacts on the performance of the service. +* When multiple clients are consuming the same service resources and restriction has to be made according to the usage per client. + +### Credits + +* [Throttling pattern](https://docs.microsoft.com/en-us/azure/architecture/patterns/throttling) +* [Cloud Design Patterns: Prescriptive Architecture Guidance for Cloud Applications (Microsoft patterns & practices)](https://www.amazon.com/gp/product/B00ITGHBBS/ref=as_li_qf_asin_il_tl?ie=UTF8&tag=javadesignpat-20&creative=9325&linkCode=as2&creativeASIN=B00ITGHBBS&linkId=12aacdd0cec04f372e7152689525631a) + +## Thread Local Storage +[⬆](#content) + +--- +layout: pattern +title: Thread Local Storage +folder: tls +permalink: /patterns/tls/ +categories: Idiom +tags: + - Performance +--- + +### Intent +Securing variables global to a thread against being spoiled by other threads. That is needed if you use class variables or static variables in your Callable object or Runnable object that are not read-only. + +### Class diagram +![alt text](./etc/tls.png "Thread Local Storage") + +### Applicability +Use the Thread Local Storage in any of the following situations + +* When you use class variables in your Callable / Runnable object that are not read-only and you use the same Callable instance in more than one thread running in parallel. +* When you use static variables in your Callable / Runnable object that are not read-only and more than one instances of the Callable / Runnable may run in parallel threads. + +## Tolerant Reader +[⬆](#content) + +--- +layout: pattern +title: Tolerant Reader +folder: tolerant-reader +permalink: /patterns/tolerant-reader/ +categories: Integration +tags: + - Decoupling +--- + +### Intent + +Tolerant Reader is an integration pattern that helps creating robust communication systems. The idea +is to be as tolerant as possible when reading data from another service. This way, when the +communication schema changes, the readers must not break. + +### Explanation + +Real world example + +> We are persisting rainbowfish objects to file and later on they need to be restored. What makes it +> problematic is that rainbowfish data structure is versioned and evolves over time. New version of +> rainbowfish needs to be able to restore old versions as well. + +In plain words + +> Tolerant Reader pattern is used to create robust communication mechanisms between services. + +[Robustness Principle](https://java-design-patterns.com/principles/#robustness-principle) says + +> Be conservative in what you do, be liberal in what you accept from others. + +**Programmatic Example** + +Here's the versioned `RainbowFish`. Notice how the second version introduces additional properties. + +```java +public class RainbowFish implements Serializable { + + private static final long serialVersionUID = 1L; + + private final String name; + private final int age; + private final int lengthMeters; + private final int weightTons; + + /** + * Constructor. + */ + public RainbowFish(String name, int age, int lengthMeters, int weightTons) { + this.name = name; + this.age = age; + this.lengthMeters = lengthMeters; + this.weightTons = weightTons; + } + + public String getName() { + return name; + } + + public int getAge() { + return age; + } + + public int getLengthMeters() { + return lengthMeters; + } + + public int getWeightTons() { + return weightTons; + } +} + +public class RainbowFishV2 extends RainbowFish { + + private static final long serialVersionUID = 1L; + + private boolean sleeping; + private boolean hungry; + private boolean angry; + + public RainbowFishV2(String name, int age, int lengthMeters, int weightTons) { + super(name, age, lengthMeters, weightTons); + } + + /** + * Constructor. + */ + public RainbowFishV2(String name, int age, int lengthMeters, int weightTons, boolean sleeping, + boolean hungry, boolean angry) { + this(name, age, lengthMeters, weightTons); + this.sleeping = sleeping; + this.hungry = hungry; + this.angry = angry; + } + + public boolean getSleeping() { + return sleeping; + } + + public boolean getHungry() { + return hungry; + } + + public boolean getAngry() { + return angry; + } +} +``` + +Next we introduce the `RainbowFishSerializer`. This is the class that implements the Tolerant Reader +pattern. + +```java +public final class RainbowFishSerializer { + + private RainbowFishSerializer() { + } + + public static void writeV1(RainbowFish rainbowFish, String filename) throws IOException { + var map = Map.of( + "name", rainbowFish.getName(), + "age", String.format("%d", rainbowFish.getAge()), + "lengthMeters", String.format("%d", rainbowFish.getLengthMeters()), + "weightTons", String.format("%d", rainbowFish.getWeightTons()) + ); + + try (var fileOut = new FileOutputStream(filename); + var objOut = new ObjectOutputStream(fileOut)) { + objOut.writeObject(map); + } + } + + public static void writeV2(RainbowFishV2 rainbowFish, String filename) throws IOException { + var map = Map.of( + "name", rainbowFish.getName(), + "age", String.format("%d", rainbowFish.getAge()), + "lengthMeters", String.format("%d", rainbowFish.getLengthMeters()), + "weightTons", String.format("%d", rainbowFish.getWeightTons()), + "angry", Boolean.toString(rainbowFish.getAngry()), + "hungry", Boolean.toString(rainbowFish.getHungry()), + "sleeping", Boolean.toString(rainbowFish.getSleeping()) + ); + + try (var fileOut = new FileOutputStream(filename); + var objOut = new ObjectOutputStream(fileOut)) { + objOut.writeObject(map); + } + } + + public static RainbowFish readV1(String filename) throws IOException, ClassNotFoundException { + Map map; + + try (var fileIn = new FileInputStream(filename); + var objIn = new ObjectInputStream(fileIn)) { + map = (Map) objIn.readObject(); + } + + return new RainbowFish( + map.get("name"), + Integer.parseInt(map.get("age")), + Integer.parseInt(map.get("lengthMeters")), + Integer.parseInt(map.get("weightTons")) + ); + } +} +``` + +And finally here's the full example in action. + +```java + var fishV1 = new RainbowFish("Zed", 10, 11, 12); + LOGGER.info("fishV1 name={} age={} length={} weight={}", fishV1.getName(), + fishV1.getAge(), fishV1.getLengthMeters(), fishV1.getWeightTons()); + RainbowFishSerializer.writeV1(fishV1, "fish1.out"); + + var deserializedRainbowFishV1 = RainbowFishSerializer.readV1("fish1.out"); + LOGGER.info("deserializedFishV1 name={} age={} length={} weight={}", + deserializedRainbowFishV1.getName(), deserializedRainbowFishV1.getAge(), + deserializedRainbowFishV1.getLengthMeters(), deserializedRainbowFishV1.getWeightTons()); + + var fishV2 = new RainbowFishV2("Scar", 5, 12, 15, true, true, true); + LOGGER.info( + "fishV2 name={} age={} length={} weight={} sleeping={} hungry={} angry={}", + fishV2.getName(), fishV2.getAge(), fishV2.getLengthMeters(), fishV2.getWeightTons(), + fishV2.getHungry(), fishV2.getAngry(), fishV2.getSleeping()); + RainbowFishSerializer.writeV2(fishV2, "fish2.out"); + + var deserializedFishV2 = RainbowFishSerializer.readV1("fish2.out"); + LOGGER.info("deserializedFishV2 name={} age={} length={} weight={}", + deserializedFishV2.getName(), deserializedFishV2.getAge(), + deserializedFishV2.getLengthMeters(), deserializedFishV2.getWeightTons()); +``` + +Program output: + +``` +fishV1 name=Zed age=10 length=11 weight=12 +deserializedFishV1 name=Zed age=10 length=11 weight=12 +fishV2 name=Scar age=5 length=12 weight=15 sleeping=true hungry=true angry=true +deserializedFishV2 name=Scar age=5 length=12 weight=15 +``` + +### Class diagram + +![alt text](./etc/tolerant_reader_urm.png "Tolerant Reader") + +### Applicability + +Use the Tolerant Reader pattern when + +* The communication schema can evolve and change and yet the receiving side should not break + +### Credits + +* [Martin Fowler - Tolerant Reader](http://martinfowler.com/bliki/TolerantReader.html) +* [Service Design Patterns: Fundamental Design Solutions for SOAP/WSDL and RESTful Web Services](https://www.amazon.com/gp/product/032154420X/ref=as_li_tl?ie=UTF8&tag=javadesignpat-20&camp=1789&creative=9325&linkCode=as2&creativeASIN=032154420X&linkId=94f9516e747ac2b449a959d5b096c73c) + + +![Java CI with Maven](https://github.com/iluwatar/java-design-patterns/workflows/Java%20CI%20with%20Maven/badge.svg) +[![License MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://raw.githubusercontent.com/iluwatar/java-design-patterns/master/LICENSE.md) +[![Lines of Code](https://sonarcloud.io/api/project_badges/measure?project=iluwatar_java-design-patterns&metric=ncloc)](https://sonarcloud.io/dashboard?id=iluwatar_java-design-patterns) +[![Coverage](https://sonarcloud.io/api/project_badges/measure?project=iluwatar_java-design-patterns&metric=coverage)](https://sonarcloud.io/dashboard?id=iluwatar_java-design-patterns) +[![Join the chat at https://gitter.im/iluwatar/java-design-patterns](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/iluwatar/java-design-patterns?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) + +[![All Contributors](https://img.shields.io/badge/all_contributors-148-orange.svg?style=flat-square)](#contributors-) + + +# Giriş + +Tasarım desenleri, bir yazılım mühendisi bir uygulamayı veya sistemi tasarlarken yaygın sorunları çözmek için kullanabileceği en iyi çözüm prensipleridir. + +Tasarım desenleri, test edilip kanıtlanmış prensipler olduğu için yazılım geliştirme sürecini hızlandırabilir. + +Tasarım desenlerini yeniden kullanmak, büyük sorunlara neden olan ince sorunları önlemeye yardımcı olur ve aynı zamanda tasarım desenlerine alışkın olan yazılım mühendisileri ve yazılım mimarları için kod okunabilirliğini artırır. + +# Başlangıç + +Bu site Java Tasarım Desenlerini sergiliyor. Çözümler, açık kaynak topluluğundan deneyimli yazılım mühendisileri ve yazılım mimarları tarafından geliştirilmiştir. Bu yazılım desenleri, detaylı açıklamalarıyla veya kaynak kodlarına bakılarak göz atılabilir. Kaynak kod örneklerinde iyi derecede açıklayıcı yorum satırlarına sahip olup ve belirli bir tasarım deseninin nasıl uygulanacağına dair programlama dersi olarak düşünülebilir. Savaşta en çok kanıtlanmış açık kaynak Java teknolojilerini kullanıyoruz. + +Bu projeye başlamadan önce çeşitli [Yazılım Tasarım İlkelerine](https://java-design-patterns.com/principles/) aşina olmalısınız. + +Tüm tasarımlar olabildiğince basit olmalıdır. [KISS](https://en.wikipedia.org/wiki/KISS_principle), [YAGNI](https://en.wikipedia.org/wiki/You_aren%27t_gonna_need_it) ve [Do The Simplest Thing That Could Possibly Work](https://learning.oreilly.com/library/view/extreme-programming-pocket/9781449399849/ch17.html) ilkeleri ile başlamalısınız. + +Bu kavramlara aşina olduktan sonra, aşağıdaki yaklaşımlardan herhangi birini kullanarak [mevcut tasarım desenlerini](https://java-design-patterns.com/patterns/) derinlemesine incelemeye başlayabilirsiniz. + +- İsme göre belirli bir tasarım deseni arayın. Bulamadınız mı? Lütfen yeni bir tasarım deseni için [bizim ile](https://github.com/iluwatar/java-design-patterns/issues) iletişime geçin. +- Performance, Gang of Four ya da Data access gibi etiketleri kullanın. +- Creational(Yaratıcı Tasarım Desenleri), Behavioral(Davranışsal Tasarım Desenleri), ve Structural(Yapısal Tasarım Desenleri) gibi tasarım kategorilerini kullanın. + +Umarım bu sitede sunulan nesne yönelimli çözümleri yazılım mimarileriniz için yararlı bulursunuz ve onları geliştirirken bizim kadar eğlenirsiniz. + +# Nasıl Katkı Sağlayabilirim + +Projeye katkıda bulunmaya istekliysen, ilgili bilgileri [geliştirici wiki'mizde](https://github.com/iluwatar/java-design-patterns/wiki) bulabilirsin. [Gitter](https://gitter.im/iluwatar/java-design-patterns) ile size yardımcı olacağız ve sorularınızı cevaplayacağız. + +# Lisans + +Bu proje, MIT lisansı koşulları altında lisanslanmıştır. + +## Trampoline +[⬆](#content) + +--- +layout: pattern +title: Trampoline +folder: trampoline +permalink: /patterns/trampoline/ +categories: Behavioral +tags: + - Performance +--- + +### Intent + +Trampoline pattern is used for implementing algorithms recursively in Java without blowing the stack +and to interleave the execution of functions without hard coding them together. + +### Explanation + +Recursion is a frequently adopted technique for solving algorithmic problems in a divide and conquer +style. For example calculating fibonacci accumulating sum and factorials. In these kinds of problems +recursion is more straightforward than their loop counterpart. Furthermore recursion may need less +code and looks more concise. There is a saying that every recursion problem can be solved using +a loop with the cost of writing code that is more difficult to understand. + +However recursion type solutions have one big caveat. For each recursive call it typically needs +an intermediate value stored and there is a limited amount of stack memory available. Running out of +stack memory creates a stack overflow error and halts the program execution. + +Trampoline pattern is a trick that allows us define recursive algorithms in Java without blowing the +stack. + +Real world example + +> A recursive Fibonacci calculation without the stack overflow problem using the Trampoline pattern. + +In plain words + +> Trampoline pattern allows recursion without running out of stack memory. + +Wikipedia says + +> In Java, trampoline refers to using reflection to avoid using inner classes, for example in event +> listeners. The time overhead of a reflection call is traded for the space overhead of an inner +> class. Trampolines in Java usually involve the creation of a GenericListener to pass events to +> an outer class. + +**Programmatic Example** + +Here's the `Trampoline` implementation in Java. + +When `get` is called on the returned Trampoline, internally it will iterate calling `jump` on the +returned `Trampoline` as long as the concrete instance returned is `Trampoline`, stopping once the +returned instance is `done`. + +```java +public interface Trampoline { + + T get(); + + default Trampoline jump() { + return this; + } + + default T result() { + return get(); + } + + default boolean complete() { + return true; + } + + static Trampoline done(final T result) { + return () -> result; + } + + static Trampoline more(final Trampoline> trampoline) { + return new Trampoline() { + @Override + public boolean complete() { + return false; + } + + @Override + public Trampoline jump() { + return trampoline.result(); + } + + @Override + public T get() { + return trampoline(this); + } + + T trampoline(final Trampoline trampoline) { + return Stream.iterate(trampoline, Trampoline::jump) + .filter(Trampoline::complete) + .findFirst() + .map(Trampoline::result) + .orElseThrow(); + } + }; + } +} +``` + +Using the `Trampoline` to get Fibonacci values. + +```java + public static Trampoline loop(int times, int prod) { + if (times == 0) { + return Trampoline.done(prod); + } else { + return Trampoline.more(() -> loop(times - 1, prod * times)); + } + } + + log.info("start pattern"); + var result = loop(10, 1).result(); + log.info("result {}", result); +``` + +Program output: + +``` +start pattern +result 3628800 +``` + +### Class diagram + +![alt text](./etc/trampoline.urm.png "Trampoline pattern class diagram") + +### Applicability + +Use the Trampoline pattern when + +* For implementing tail recursive function. This pattern allows to switch on a stackless operation. +* For interleaving the execution of two or more functions on the same thread. + +### Known uses + +* [cyclops-react](https://github.com/aol/cyclops-react) + +### Credits + +* [Trampolining: a practical guide for awesome Java Developers](https://medium.com/@johnmcclean/trampolining-a-practical-guide-for-awesome-java-developers-4b657d9c3076) +* [Trampoline in java ](http://mindprod.com/jgloss/trampoline.html) +* [Laziness, trampolines, monoids and other functional amenities: this is not your father's Java](https://www.slideshare.net/mariofusco/lazine) +* [Trampoline implementation](https://github.com/bodar/totallylazy/blob/master/src/com/googlecode/totallylazy/Trampoline.java) +* [What is a trampoline function?](https://stackoverflow.com/questions/189725/what-is-a-trampoline-function) +* [Modern Java in Action: Lambdas, streams, functional and reactive programming](https://www.amazon.com/gp/product/1617293563/ref=as_li_qf_asin_il_tl?ie=UTF8&tag=javadesignpat-20&creative=9325&linkCode=as2&creativeASIN=1617293563&linkId=ad53ae6f9f7c0982e759c3527bd2595c) +* [Java 8 in Action: Lambdas, Streams, and functional-style programming](https://www.amazon.com/gp/product/1617291994/ref=as_li_qf_asin_il_tl?ie=UTF8&tag=javadesignpat-20&creative=9325&linkCode=as2&creativeASIN=1617291994&linkId=e3e5665b0732c59c9d884896ffe54f4f) + +## Transaction Script +[⬆](#content) + +--- +layout: pattern +title: Transaction Script +folder: transaction-script +permalink: /patterns/transaction-script/ +categories: Behavioral +tags: + - Data access +--- + +### Intent + +Transaction Script organizes business logic by procedures where each procedure handles a single +request from the presentation. + +### Explanation + +Real world example + +> You need to create a hotel room booking system. Since the requirements are quite simple we intend +> to use the Transaction Script pattern here. + +In plain words + +> Transaction Script organizes business logic into transactions that the system needs to carry out. + +Programmatic example + +The `Hotel` class takes care of booking and cancelling room reservations. + +```java +public class Hotel { + private static final Logger LOGGER = LoggerFactory.getLogger(App.class); + + private final HotelDaoImpl hotelDao; + + public Hotel(HotelDaoImpl hotelDao) { + this.hotelDao = hotelDao; + } + + public void bookRoom(int roomNumber) throws Exception { + + Optional room = hotelDao.getById(roomNumber); + + if (room.isEmpty()) { + throw new Exception("Room number: " + roomNumber + " does not exist"); + } else { + if (room.get().isBooked()) { + throw new Exception("Room already booked!"); + } else { + Room updateRoomBooking = room.get(); + updateRoomBooking.setBooked(true); + hotelDao.update(updateRoomBooking); + } + } + } + + public void cancelRoomBooking(int roomNumber) throws Exception { + + Optional room = hotelDao.getById(roomNumber); + + if (room.isEmpty()) { + throw new Exception("Room number: " + roomNumber + " does not exist"); + } else { + if (room.get().isBooked()) { + Room updateRoomBooking = room.get(); + updateRoomBooking.setBooked(false); + int refundAmount = updateRoomBooking.getPrice(); + hotelDao.update(updateRoomBooking); + + LOGGER.info("Booking cancelled for room number: " + roomNumber); + LOGGER.info(refundAmount + " is refunded"); + } else { + throw new Exception("No booking for the room exists"); + } + } + } +} +``` + +The `Hotel` class has two methods, one for booking and cancelling a room respectively. Each one of +them handles a single transaction in the system, making `Hotel` implement the Transaction Script +pattern. + +The `bookRoom` method consolidates all the needed steps like checking if the room is already booked +or not, if not booked then books the room and updates the database by using the DAO. + +The `cancelRoom` method consolidates steps like checking if the room is booked or not, +if booked then calculates the refund amount and updates the database using the DAO. + +### Class diagram + +![alt text](./etc/transaction-script.png "Transaction script model") + +### Applicability + +Use the Transaction Script pattern when the application has only a small amount of logic and that +logic won't be extended in the future. + +### Consequences + +* As the business logic gets more complicated, +it gets progressively harder to keep the transaction script +in a well-designed state. +* Code duplication between transaction scripts can occur. +* Normally not easy to refactor transactions script to other domain logic +patterns. + +### Related patterns + +* Domain Model +* Table Module +* Service Layer + +### Credits + +* [Transaction Script Pattern](https://dzone.com/articles/transaction-script-pattern#:~:text=Transaction%20Script%20(TS)%20is%20the,need%20big%20architecture%20behind%20them.) +* [Transaction Script](https://www.informit.com/articles/article.aspx?p=1398617) +* [Patterns of Enterprise Application Architecture](https://www.amazon.com/gp/product/0321127420/ref=as_li_qf_asin_il_tl?ie=UTF8&tag=javadesignpat-20&creative=9325&linkCode=as2&creativeASIN=0321127420&linkId=18acc13ba60d66690009505577c45c04) + +## Twin +[⬆](#content) + +--- +layout: pattern +title: Twin +folder: twin +permalink: /patterns/twin/ +categories: Structural +tags: + - Extensibility +--- + +### Intent +Twin pattern is a design pattern which provides a standard solution to simulate multiple +inheritance in java + +### Class diagram +![alt text](./etc/twin.png "Twin") + +### Applicability +Use the Twin idiom when + +* To simulate multiple inheritance in a language that does not support this feature. +* To avoid certain problems of multiple inheritance such as name clashes. + +### Credits + +* [Twin – A Design Pattern for Modeling Multiple Inheritance](http://www.ssw.uni-linz.ac.at/Research/Papers/Moe99/Paper.pdf) + + +## Type Object Pattern +[⬆](#content) + +--- +layout: pattern +title: Type-Object +folder: typeobjectpattern +permalink: /patterns/typeobjectpattern/ +categories: Behavioral +tags: + - Game programming + - Extensibility +--- + +### Intent +As explained in the book Game Programming Patterns by Robert Nystrom, type object pattern helps in + +> Allowing flexible creation of new “classes” by creating a single class, each instance of which represents a different type of object + +### Explanation +Say, we are working on a game which has a hero and many monsters which are going to attack the hero. These monsters have certain attributes like attack, points etc. and come in different 'breeds' like zombie or ogres. The obvious answer is to have a base Monster class which has some fields and methods, which may be overriden by subclasses like the Zombie or Ogre class. But as we continue to build the game, there may be more and more breeds of monsters added and certain attributes may need to be changed in the existing monsters too. The OOP solution of inheriting from the base class would not be an efficient method in this case. +Using the type-object pattern, instead of creating many classes inheriting from a base class, we have 1 class with a field which represents the 'type' of object. This makes the code cleaner and object instantiation also becomes as easy as parsing a json file with the object properties. + +### Class diagram +![alt text](./etc/typeobjectpattern.urm.png "Type-Object pattern class diagram") + +### Applicability +This pattern can be used when: + +* We don’t know what types we will need up front. +* We want to be able to modify or add new types without having to recompile or change code. +* Only difference between the different 'types' of objects is the data, not the behaviour. + +### Credits + +* [Game Programming Patterns - Type Object](http://gameprogrammingpatterns.com/type-object.html) +* [Types as Objects Pattern](http://www.cs.sjsu.edu/~pearce/modules/patterns/analysis/top.htm) + +## Unit of Work +[⬆](#content) + +--- +layout: pattern +title: Unit Of Work +folder: unit-of-work +permalink: /patterns/unit-of-work/ + +categories: Architectural +tags: + - Data access + - Performance +--- + +### Intent + +When a business transaction is completed, all the the updates are sent as one big unit of work to be +persisted in one go to minimize database round-trips. + +### Explanation + +Real world example + +> We have a database containing student information. Administrators all over the country are +> constantly updating this information and it causes high load on the database server. To make the +> load more manageable we apply to Unit of Work pattern to send many small updates in batches. + +In plain words + +> Unit of Work merges many small database updates in single batch to optimize the number of +> round-trips. + +[MartinFowler.com](https://martinfowler.com/eaaCatalog/unitOfWork.html) says + +> Maintains a list of objects affected by a business transaction and coordinates the writing out of +> changes and the resolution of concurrency problems. + +**Programmatic Example** + +Here's the `Student` entity that is being persisted to the database. + +```java +public class Student { + private final Integer id; + private final String name; + private final String address; + + public Student(Integer id, String name, String address) { + this.id = id; + this.name = name; + this.address = address; + } + + public String getName() { + return name; + } + + public Integer getId() { + return id; + } + + public String getAddress() { + return address; + } +} +``` + +The essence of the implementation is the `StudentRepository` implementing the Unit of Work pattern. +It maintains a map of database operations (`context`) that need to be done and when `commit` is +called it applies them in single batch. + +```java +public interface IUnitOfWork { + + String INSERT = "INSERT"; + String DELETE = "DELETE"; + String MODIFY = "MODIFY"; + + void registerNew(T entity); + + void registerModified(T entity); + + void registerDeleted(T entity); + + void commit(); +} + +public class StudentRepository implements IUnitOfWork { + private static final Logger LOGGER = LoggerFactory.getLogger(StudentRepository.class); + + private final Map> context; + private final StudentDatabase studentDatabase; + + public StudentRepository(Map> context, StudentDatabase studentDatabase) { + this.context = context; + this.studentDatabase = studentDatabase; + } + + @Override + public void registerNew(Student student) { + LOGGER.info("Registering {} for insert in context.", student.getName()); + register(student, IUnitOfWork.INSERT); + } + + @Override + public void registerModified(Student student) { + LOGGER.info("Registering {} for modify in context.", student.getName()); + register(student, IUnitOfWork.MODIFY); + + } + + @Override + public void registerDeleted(Student student) { + LOGGER.info("Registering {} for delete in context.", student.getName()); + register(student, IUnitOfWork.DELETE); + } + + private void register(Student student, String operation) { + var studentsToOperate = context.get(operation); + if (studentsToOperate == null) { + studentsToOperate = new ArrayList<>(); + } + studentsToOperate.add(student); + context.put(operation, studentsToOperate); + } + + @Override + public void commit() { + if (context == null || context.size() == 0) { + return; + } + LOGGER.info("Commit started"); + if (context.containsKey(IUnitOfWork.INSERT)) { + commitInsert(); + } + + if (context.containsKey(IUnitOfWork.MODIFY)) { + commitModify(); + } + if (context.containsKey(IUnitOfWork.DELETE)) { + commitDelete(); + } + LOGGER.info("Commit finished."); + } + + private void commitInsert() { + var studentsToBeInserted = context.get(IUnitOfWork.INSERT); + for (var student : studentsToBeInserted) { + LOGGER.info("Saving {} to database.", student.getName()); + studentDatabase.insert(student); + } + } + + private void commitModify() { + var modifiedStudents = context.get(IUnitOfWork.MODIFY); + for (var student : modifiedStudents) { + LOGGER.info("Modifying {} to database.", student.getName()); + studentDatabase.modify(student); + } + } + + private void commitDelete() { + var deletedStudents = context.get(IUnitOfWork.DELETE); + for (var student : deletedStudents) { + LOGGER.info("Deleting {} to database.", student.getName()); + studentDatabase.delete(student); + } + } +} +``` + +Finally, here's how we use the `StudentRepository` and `commit` the transaction. + +```java + studentRepository.registerNew(ram); + studentRepository.registerModified(shyam); + studentRepository.registerDeleted(gopi); + studentRepository.commit(); +``` + +### Class diagram + +![alt text](etc/unit-of-work.urm.png "unit-of-work") + +### Applicability + +Use the Unit Of Work pattern when + +* To optimize the time taken for database transactions. +* To send changes to database as a unit of work which ensures atomicity of the transaction. +* To reduce number of database calls. + +### Tutorials + +* [Repository and Unit of Work Pattern](https://www.programmingwithwolfgang.com/repository-and-unit-of-work-pattern/) +* [Unit of Work - a Design Pattern](https://mono.software/2017/01/13/unit-of-work-a-design-pattern/) + +### Credits + +* [Design Pattern - Unit Of Work Pattern](https://www.codeproject.com/Articles/581487/Unit-of-Work-Design-Pattern) +* [Unit Of Work](https://martinfowler.com/eaaCatalog/unitOfWork.html) +* [Patterns of Enterprise Application Architecture](https://www.amazon.com/gp/product/0321127420/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0321127420&linkCode=as2&tag=javadesignpat-20&linkId=d9f7d37b032ca6e96253562d075fcc4a) + +## Update Method +[⬆](#content) + +--- +layout: pattern +title: Update Method +folder: update-method +permalink: /patterns/update-method/ +categories: Behavioral +tags: + - Game programming +--- + +### Intent +Update method pattern simulates a collection of independent objects by telling each to process one frame of behavior at a time. + +### Explanation +The game world maintains a collection of objects. Each object implements an update method that simulates one frame of the object’s behavior. Each frame, the game updates every object in the collection. + +To learn more about how the game loop runs and when the update methods are invoked, please refer to Game Loop Pattern. + +### Class diagram +![alt text](./etc/update-method.urm.png "Update Method pattern class diagram") + +### Applicability +If the Game Loop pattern is the best thing since sliced bread, then the Update Method pattern is its butter. A wide swath of games featuring live entities that the player interacts with use this pattern in some form or other. If the game has space marines, dragons, Martians, ghosts, or athletes, there’s a good chance it uses this pattern. + +However, if the game is more abstract and the moving pieces are less like living actors and more like pieces on a chessboard, this pattern is often a poor fit. In a game like chess, you don’t need to simulate all of the pieces concurrently, and you probably don’t need to tell the pawns to update themselves every frame. + +Update methods work well when: + +- Your game has a number of objects or systems that need to run simultaneously. +- Each object’s behavior is mostly independent of the others. +- The objects need to be simulated over time. + +### Credits + +* [Game Programming Patterns - Update Method](http://gameprogrammingpatterns.com/update-method.html) + + +## Value Object +[⬆](#content) + +--- +layout: pattern +title: Value Object +folder: value-object +permalink: /patterns/value-object/ +categories: Creational +tags: + - Instantiation +--- + +### Intent +Provide objects which follow value semantics rather than reference semantics. +This means value objects' equality are not based on identity. Two value objects are +equal when they have the same value, not necessarily being the same object. + +### Class diagram +![alt text](./etc/value-object.png "Value Object") + +### Applicability +Use the Value Object when + +* You need to measure the objects' equality based on the objects' value + +## Real world examples + +* [java.util.Optional](https://docs.oracle.com/javase/8/docs/api/java/util/Optional.html) +* [java.time.LocalDate](https://docs.oracle.com/javase/8/docs/api/java/time/LocalDate.html) +* [joda-time, money, beans](http://www.joda.org/) + +### Credits + +* [Patterns of Enterprise Application Architecture](http://www.martinfowler.com/books/eaa.html) +* [VALJOs - Value Java Objects : Stephen Colebourne's blog](http://blog.joda.org/2014/03/valjos-value-java-objects.html) +* [Value Object : Wikipedia](https://en.wikipedia.org/wiki/Value_object) +* [J2EE Design Patterns](https://www.amazon.com/gp/product/0596004273/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596004273&linkCode=as2&tag=javadesignpat-20&linkId=f27d2644fbe5026ea448791a8ad09c94) + + +## Version Number +[⬆](#content) + +--- +layout: pattern +title: Version Number +folder: versionnumber +permalink: /patterns/versionnumber/ +description: Entity versioning with version number + +categories: + - Concurrency + +tags: + - Data access + - Microservices +--- + +## Name / classification + +Version Number. + +### Also known as + +Entity Versioning, Optimistic Locking. + +### Intent + +Resolve concurrency conflicts when multiple clients are trying to update same entity simultaneously. + +### Explanation + +Real world example + +> Alice and Bob are working on the book, which stored in the database. Our heroes are making +> changes simultaneously, and we need some mechanism to prevent them from overwriting each other. + +In plain words + +> Version Number pattern grants protection against concurrent updates to same entity. + +Wikipedia says + +> Optimistic concurrency control assumes that multiple transactions can frequently complete +> without interfering with each other. While running, transactions use data resources without +> acquiring locks on those resources. Before committing, each transaction verifies that no other +> transaction has modified the data it has read. If the check reveals conflicting modifications, +> the committing transaction rolls back and can be restarted. + +**Programmatic Example** + +We have a `Book` entity, which is versioned, and has a copy-constructor: + +```java +public class Book { + private long id; + private String title = ""; + private String author = ""; + + private long version = 0; // version number + + public Book(Book book) { + this.id = book.id; + this.title = book.title; + this.author = book.author; + this.version = book.version; + } + + // getters and setters are omitted here +} +``` + +We also have `BookRepository`, which implements concurrency control: + +```java +public class BookRepository { + private final Map collection = new HashMap<>(); + + public void update(Book book) throws BookNotFoundException, VersionMismatchException { + if (!collection.containsKey(book.getId())) { + throw new BookNotFoundException("Not found book with id: " + book.getId()); + } + + var latestBook = collection.get(book.getId()); + if (book.getVersion() != latestBook.getVersion()) { + throw new VersionMismatchException( + "Tried to update stale version " + book.getVersion() + + " while actual version is " + latestBook.getVersion() + ); + } + + // update version, including client representation - modify by reference here + book.setVersion(book.getVersion() + 1); + + // save book copy to repository + collection.put(book.getId(), new Book(book)); + } + + public Book get(long bookId) throws BookNotFoundException { + if (!collection.containsKey(bookId)) { + throw new BookNotFoundException("Not found book with id: " + bookId); + } + + // return copy of the book + return new Book(collection.get(bookId)); + } +} +``` + +Here's the concurrency control in action: + +```java +var bookId = 1; +// Alice and Bob took the book concurrently +final var aliceBook = bookRepository.get(bookId); +final var bobBook = bookRepository.get(bookId); + +aliceBook.setTitle("Kama Sutra"); // Alice has updated book title +bookRepository.update(aliceBook); // and successfully saved book in database +LOGGER.info("Alice updates the book with new version {}", aliceBook.getVersion()); + +// now Bob has the stale version of the book with empty title and version = 0 +// while actual book in database has filled title and version = 1 +bobBook.setAuthor("Vatsyayana Mallanaga"); // Bob updates the author +try { + LOGGER.info("Bob tries to update the book with his version {}", bobBook.getVersion()); + bookRepository.update(bobBook); // Bob tries to save his book to database +} catch (VersionMismatchException e) { + // Bob update fails, and book in repository remained untouchable + LOGGER.info("Exception: {}", e.getMessage()); + // Now Bob should reread actual book from repository, do his changes again and save again +} +``` + +Program output: + +```java +Alice updates the book with new version 1 +Bob tries to update the book with his version 0 +Exception: Tried to update stale version 0 while actual version is 1 +``` + +### Class diagram + +![alt text](./etc/version-number.urm.png "Version Number pattern class diagram") + +### Applicability + +Use Version Number for: + +* resolving concurrent write-access to the data +* strong data consistency + +### Tutorials +* [Version Number Pattern Tutorial](http://www.java2s.com/Tutorial/Java/0355__JPA/VersioningEntity.htm) + +### Known uses + * [Hibernate](https://vladmihalcea.com/jpa-entity-version-property-hibernate/) + * [Elasticsearch](https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-index_.html#index-versioning) + * [Apache Solr](https://lucene.apache.org/solr/guide/6_6/updating-parts-of-documents.html) + +### Consequences +Version Number pattern allows to implement a concurrency control, which is usually done +via Optimistic Offline Lock pattern. + +### Related patterns +* [Optimistic Offline Lock](https://martinfowler.com/eaaCatalog/optimisticOfflineLock.html) + +### Credits +* [Optimistic Locking in JPA](https://www.baeldung.com/jpa-optimistic-locking) +* [JPA entity versioning](https://www.byteslounge.com/tutorials/jpa-entity-versioning-version-and-optimistic-locking) +* [J2EE Design Patterns](http://ommolketab.ir/aaf-lib/axkwht7wxrhvgs2aqkxse8hihyu9zv.pdf) + +## Visitor +[⬆](#content) + +--- +layout: pattern +title: Visitor +folder: visitor +permalink: /patterns/visitor/ +categories: Behavioral +tags: + - Gang of Four +--- + +### Intent + +Represent an operation to be performed on the elements of an object structure. Visitor lets you +define a new operation without changing the classes of the elements on which it operates. + +### Explanation + +Real world example + +> Consider a tree structure with army units. Commander has two sergeants under it and each sergeant +> has three soldiers under them. Given that the hierarchy implements the visitor pattern, we can +> easily create new objects that interact with the commander, sergeants, soldiers or all of them. + +In plain words + +> Visitor pattern defines operations that can be performed on the nodes of the data structure. + +Wikipedia says + +> In object-oriented programming and software engineering, the visitor design pattern is a way of +> separating an algorithm from an object structure on which it operates. A practical result of this +> separation is the ability to add new operations to existing object structures without modifying +> the structures. + +**Programmatic Example** + +Given the army unit example from above, we first have the Unit and UnitVisitor base types. + +```java +public abstract class Unit { + + private final Unit[] children; + + public Unit(Unit... children) { + this.children = children; + } + + public void accept(UnitVisitor visitor) { + Arrays.stream(children).forEach(child -> child.accept(visitor)); + } +} + +public interface UnitVisitor { + + void visitSoldier(Soldier soldier); + + void visitSergeant(Sergeant sergeant); + + void visitCommander(Commander commander); +} +``` + +Then we have the concrete units. + +```java +public class Commander extends Unit { + + public Commander(Unit... children) { + super(children); + } + + @Override + public void accept(UnitVisitor visitor) { + visitor.visitCommander(this); + super.accept(visitor); + } + + @Override + public String toString() { + return "commander"; + } +} + +public class Sergeant extends Unit { + + public Sergeant(Unit... children) { + super(children); + } + + @Override + public void accept(UnitVisitor visitor) { + visitor.visitSergeant(this); + super.accept(visitor); + } + + @Override + public String toString() { + return "sergeant"; + } +} + +public class Soldier extends Unit { + + public Soldier(Unit... children) { + super(children); + } + + @Override + public void accept(UnitVisitor visitor) { + visitor.visitSoldier(this); + super.accept(visitor); + } + + @Override + public String toString() { + return "soldier"; + } +} +``` + +Here are then some concrete visitors. + +```java +public class CommanderVisitor implements UnitVisitor { + + private static final Logger LOGGER = LoggerFactory.getLogger(CommanderVisitor.class); + + @Override + public void visitSoldier(Soldier soldier) { + // Do nothing + } + + @Override + public void visitSergeant(Sergeant sergeant) { + // Do nothing + } + + @Override + public void visitCommander(Commander commander) { + LOGGER.info("Good to see you {}", commander); + } +} + +public class SergeantVisitor implements UnitVisitor { + + private static final Logger LOGGER = LoggerFactory.getLogger(SergeantVisitor.class); + + @Override + public void visitSoldier(Soldier soldier) { + // Do nothing + } + + @Override + public void visitSergeant(Sergeant sergeant) { + LOGGER.info("Hello {}", sergeant); + } + + @Override + public void visitCommander(Commander commander) { + // Do nothing + } +} + +public class SoldierVisitor implements UnitVisitor { + + private static final Logger LOGGER = LoggerFactory.getLogger(SoldierVisitor.class); + + @Override + public void visitSoldier(Soldier soldier) { + LOGGER.info("Greetings {}", soldier); + } + + @Override + public void visitSergeant(Sergeant sergeant) { + // Do nothing + } + + @Override + public void visitCommander(Commander commander) { + // Do nothing + } +} +``` + +Finally, we can show the power of visitors in action. + +```java +commander.accept(new SoldierVisitor()); +commander.accept(new SergeantVisitor()); +commander.accept(new CommanderVisitor()); +``` + +Program output: + +``` +Greetings soldier +Greetings soldier +Greetings soldier +Greetings soldier +Greetings soldier +Greetings soldier +Hello sergeant +Hello sergeant +Good to see you commander +``` + +### Class diagram + +![alt text](./etc/visitor_1.png "Visitor") + +### Applicability + +Use the Visitor pattern when + +* An object structure contains many classes of objects with differing interfaces, and you want to perform operations on these objects that depend on their concrete classes. +* Many distinct and unrelated operations need to be performed on objects in an object structure, and you want to avoid "polluting" their classes with these operations. Visitor lets you keep related operations together by defining them in one class. When the object structure is shared by many applications, use Visitor to put operations in just those applications that need them. +* The classes defining the object structure rarely change, but you often want to define new operations over the structure. Changing the object structure classes requires redefining the interface to all visitors, which is potentially costly. If the object structure classes change often, then it's probably better to define the operations in those classes. + +## Real world examples + +* [Apache Wicket](https://github.com/apache/wicket) component tree, see [MarkupContainer](https://github.com/apache/wicket/blob/b60ec64d0b50a611a9549809c9ab216f0ffa3ae3/wicket-core/src/main/java/org/apache/wicket/MarkupContainer.java) +* [javax.lang.model.element.AnnotationValue](http://docs.oracle.com/javase/8/docs/api/javax/lang/model/element/AnnotationValue.html) and [AnnotationValueVisitor](http://docs.oracle.com/javase/8/docs/api/javax/lang/model/element/AnnotationValueVisitor.html) +* [javax.lang.model.element.Element](http://docs.oracle.com/javase/8/docs/api/javax/lang/model/element/Element.html) and [Element Visitor](http://docs.oracle.com/javase/8/docs/api/javax/lang/model/element/ElementVisitor.html) +* [java.nio.file.FileVisitor](http://docs.oracle.com/javase/8/docs/api/java/nio/file/FileVisitor.html) + +### Credits + +* [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/gp/product/0201633612/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0201633612&linkCode=as2&tag=javadesignpat-20&linkId=675d49790ce11db99d90bde47f1aeb59) +* [Head First Design Patterns: A Brain-Friendly Guide](https://www.amazon.com/gp/product/0596007124/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596007124&linkCode=as2&tag=javadesignpat-20&linkId=6b8b6eea86021af6c8e3cd3fc382cb5b) +* [Refactoring to Patterns](https://www.amazon.com/gp/product/0321213351/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0321213351&linkCode=as2&tag=javadesignpat-20&linkId=2a76fcb387234bc71b1c61150b3cc3a7) + + + +![Java CI with Maven](https://github.com/iluwatar/java-design-patterns/workflows/Java%20CI%20with%20Maven/badge.svg) [](https://raw.githubusercontent.com/iluwatar/java-design-patterns/master/LICENSE.md)![License MIT](https://img.shields.io/badge/license-MIT-blue.svg) [](https://gitter.im/iluwatar/java-design-patterns?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)![Join the chat at https://gitter.im/iluwatar/java-design-patterns](https://badges.gitter.im/Join%20Chat.svg) [](https://sonarcloud.io/dashboard?id=iluwatar_java-design-patterns)![Sonarcloud Status](https://sonarcloud.io/api/project_badges/measure?project=iluwatar_java-design-patterns&metric=alert_status) + + + + diff --git a/special-case/src/main/java/com/iluwatar/specialcase/InsufficientFunds.java~merged b/special-case/src/main/java/com/iluwatar/specialcase/InsufficientFunds.java~merged new file mode 100644 index 000000000000..d421907f9491 --- /dev/null +++ b/special-case/src/main/java/com/iluwatar/specialcase/InsufficientFunds.java~merged @@ -0,0 +1,67 @@ +/* + * The MIT License +<<<<<<< HEAD + * Copyright © 2014-2019 Ilkka Seppälä +======= + * Copyright © 2014-2021 Ilkka Seppälä +>>>>>>> 965d38f1393e4eaf67872b45d93af4660f8c50de + * + * 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.specialcase; + +<<<<<<< HEAD +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class InsufficientFunds implements ReceiptViewModel { + + private static final Logger LOGGER = LoggerFactory.getLogger(InsufficientFunds.class); + +======= +import lombok.extern.slf4j.Slf4j; + +@Slf4j +public class InsufficientFunds implements ReceiptViewModel { + +>>>>>>> 965d38f1393e4eaf67872b45d93af4660f8c50de + private String userName; + private Double amount; + private String itemName; + + /** + * Constructor of InsufficientFunds. + * + * @param userName of the user + * @param amount of the user's account + * @param itemName of the item + */ + public InsufficientFunds(String userName, Double amount, String itemName) { + this.userName = userName; + this.amount = amount; + this.itemName = itemName; + } + + @Override + public void show() { + LOGGER.info("Insufficient funds: " + amount + " of user: " + userName + + " for buying item: " + itemName); + } +} From 7273ee4a576ed65a5c8e791dd688bbb0831f5ce9 Mon Sep 17 00:00:00 2001 From: Miroslav Trninic Date: Mon, 29 Mar 2021 18:59:10 +0200 Subject: [PATCH 2/8] update upstream --- .../specialcase/DomainServices.java~merged | 77 +++++++++++++++++ version-number/pom.xml~merged | 82 +++++++++++++++++++ .../versionnumber/AppTest.java~merged | 72 ++++++++++++++++ 3 files changed, 231 insertions(+) create mode 100644 special-case/src/main/java/com/iluwatar/specialcase/DomainServices.java~merged create mode 100644 version-number/pom.xml~merged create mode 100644 version-number/src/test/java/com/iluwatar/versionnumber/AppTest.java~merged diff --git a/special-case/src/main/java/com/iluwatar/specialcase/DomainServices.java~merged b/special-case/src/main/java/com/iluwatar/specialcase/DomainServices.java~merged new file mode 100644 index 000000000000..873e5449ba8c --- /dev/null +++ b/special-case/src/main/java/com/iluwatar/specialcase/DomainServices.java~merged @@ -0,0 +1,77 @@ +<<<<<<< HEAD +======= +<<<<<<< HEAD:active-object/src/main/java/com/iluwatar/activeobject/Orc.java +>>>>>>> 7d109b2599f3dfb4ad9f42923b8178a205a5edae +/* + * The MIT License + * Copyright © 2014-2021 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. + */ + +<<<<<<< HEAD +package com.iluwatar.specialcase; + +public interface DomainServices { +} +======= +package com.iluwatar.activeobject; + +/** + * An implementation of the ActiveCreature class. + * @author Noam Greenshtain + * + */ +public class Orc extends ActiveCreature { + + public Orc(String name) { + super(name); + } + +} +======= +/* + * The MIT License + * Copyright © 2014-2019 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.specialcase; + +public interface DomainServices { +} +>>>>>>> 7d109b2599f3dfb4ad9f42923b8178a205a5edae:special-case/src/main/java/com/iluwatar/specialcase/DomainServices.java +>>>>>>> 7d109b2599f3dfb4ad9f42923b8178a205a5edae diff --git a/version-number/pom.xml~merged b/version-number/pom.xml~merged new file mode 100644 index 000000000000..3046452a46a0 --- /dev/null +++ b/version-number/pom.xml~merged @@ -0,0 +1,82 @@ + + + + 4.0.0 + + com.iluwatar + java-design-patterns + 1.24.0-SNAPSHOT + +<<<<<<< HEAD + version-number +======= +<<<<<<< HEAD:parameter-object/pom.xml + parameter-object +======= + version-number +>>>>>>> 7d109b2599f3dfb4ad9f42923b8178a205a5edae:version-number/pom.xml +>>>>>>> 7d109b2599f3dfb4ad9f42923b8178a205a5edae + + + org.junit.jupiter + junit-jupiter-engine + test + + + org.mockito + mockito-core + test + + + + + + org.apache.maven.plugins + maven-assembly-plugin + + + + + +<<<<<<< HEAD + com.iluwatar.versionnumber.App +======= +<<<<<<< HEAD:parameter-object/pom.xml + com.iluwatar.parameter.object.App +======= + com.iluwatar.versionnumber.App +>>>>>>> 7d109b2599f3dfb4ad9f42923b8178a205a5edae:version-number/pom.xml +>>>>>>> 7d109b2599f3dfb4ad9f42923b8178a205a5edae + + + + + + + + + diff --git a/version-number/src/test/java/com/iluwatar/versionnumber/AppTest.java~merged b/version-number/src/test/java/com/iluwatar/versionnumber/AppTest.java~merged new file mode 100644 index 000000000000..5122d4ff4fa5 --- /dev/null +++ b/version-number/src/test/java/com/iluwatar/versionnumber/AppTest.java~merged @@ -0,0 +1,72 @@ +/* + * The MIT License + * Copyright © 2014-2021 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. + */ + +<<<<<<< HEAD +package com.iluwatar.versionnumber; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; + +======= +<<<<<<< HEAD:active-object/src/test/java/com/iluwatar/activeobject/AppTest.java +package com.iluwatar.activeobject; + +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +======= +package com.iluwatar.versionnumber; +>>>>>>> 7d109b2599f3dfb4ad9f42923b8178a205a5edae:version-number/src/test/java/com/iluwatar/versionnumber/AppTest.java + +import org.junit.jupiter.api.Test; + + +<<<<<<< HEAD:active-object/src/test/java/com/iluwatar/activeobject/AppTest.java +class AppTest { + + @Test + void shouldExecuteApplicationWithoutException() { + assertDoesNotThrow(() -> App.main(new String[]{})); + } +======= +>>>>>>> 7d109b2599f3dfb4ad9f42923b8178a205a5edae +/** + * Application test + */ +class AppTest { + + /** + * Issue: Add at least one assertion to this test case. + * + * Solution: Inserted assertion to check whether the execution of the main method in {@link App#main(String[])} + * throws an exception. + */ + + @Test + void shouldExecuteApplicationWithoutException() { + assertDoesNotThrow(() -> App.main(new String[]{})); + } +<<<<<<< HEAD +======= +>>>>>>> 7d109b2599f3dfb4ad9f42923b8178a205a5edae:version-number/src/test/java/com/iluwatar/versionnumber/AppTest.java +>>>>>>> 7d109b2599f3dfb4ad9f42923b8178a205a5edae +} From 5d004744a5f6c25726d8d0edc4410592d7fcb5b1 Mon Sep 17 00:00:00 2001 From: Miroslav Trninic Date: Tue, 30 Mar 2021 23:40:27 +0200 Subject: [PATCH 3/8] Tue 30 Mar 2021 11:40:27 PM CEST --- etc/Bass-Drum-1.aif | Bin 0 -> 220938 bytes etc/Bass-Drum-1.wav | Bin 0 -> 221080 bytes etc/Closed-Hi-Hat-1.aif | Bin 0 -> 13042 bytes etc/Closed-Hi-Hat-1.wav | Bin 0 -> 13032 bytes etc/Converter.ucls | 51 + etc/MarkerDiagram.png | Bin 0 -> 6461 bytes etc/MarkerDiagram.ucls | 41 + etc/MonoState.ucls | 53 + etc/ServiceDiagram.png | Bin 0 -> 23591 bytes etc/StateDiagram.png | Bin 0 -> 19396 bytes etc/abstract-document.png | Bin 0 -> 96228 bytes etc/abstract-document.ucls | 142 ++ etc/abstract-document.urm.puml | 65 + etc/abstract-factory.urm.png | Bin 0 -> 82368 bytes etc/abstract-factory.urm.puml | 101 ++ etc/active-object.urm.PNG | Bin 0 -> 19466 bytes etc/active-object.urm.puml | 25 + etc/acyclic-visitor.png | Bin 0 -> 49064 bytes etc/acyclic-visitor.urm.puml | 53 + etc/adapter.urm.png | Bin 0 -> 25425 bytes etc/adapter.urm.puml | 31 + etc/aggregator-microservices.urm.puml | 2 + etc/aggregator.gif | Bin 0 -> 2413 bytes etc/ambassador.urm.png | Bin 0 -> 49248 bytes etc/ambassador.urm.puml | 47 + etc/api-gateway.png | Bin 0 -> 18323 bytes etc/api-gateway.ucls | 97 ++ etc/api-gateway.urm.puml | 2 + etc/arrange-act-assert.urm.puml | 11 + etc/async-method-invocation.png | Bin 0 -> 36923 bytes etc/async-method-invocation.ucls | 85 ++ etc/async-method-invocation.urm.puml | 51 + etc/aws-black.png | Bin 0 -> 9262 bytes etc/azure-black.png | Bin 0 -> 4707 bytes etc/balking.png | Bin 0 -> 21427 bytes etc/balking.ucls | 46 + etc/balking.urm.puml | 30 + etc/bridge.urm.png | Bin 0 -> 43639 bytes etc/bridge.urm.puml | 58 + etc/bst.jpg | Bin 0 -> 77452 bytes etc/builder.urm.png | Bin 0 -> 94868 bytes etc/builder.urm.puml | 100 ++ etc/business-delegate.urm.png | Bin 0 -> 50060 bytes etc/business-delegate.urm.puml | 46 + etc/bytecode.urm.png | Bin 0 -> 86123 bytes etc/bytecode.urm.puml | 73 + etc/caching.png | Bin 0 -> 114847 bytes etc/caching.ucls | 90 ++ etc/caching.urm.puml | 119 ++ etc/callback.png | Bin 0 -> 18256 bytes etc/callback.ucls | 41 + etc/callback.urm.puml | 23 + etc/chain.urm.png | Bin 0 -> 60093 bytes etc/chain.urm.puml | 61 + etc/circuit-breaker.urm.png | Bin 0 -> 80659 bytes etc/circuit-breaker.urm.puml | 69 + etc/class_diagram.png | Bin 0 -> 32958 bytes etc/classes.png | Bin 0 -> 45639 bytes etc/classes.ucls | 124 ++ etc/collection-pipeline.png | Bin 0 -> 27282 bytes etc/collection-pipeline.ucls | 98 ++ etc/collection-pipeline.urm.puml | 52 + etc/combinator.urm.png | Bin 0 -> 22657 bytes etc/combinator.urm.puml | 26 + etc/command.png | Bin 0 -> 51106 bytes etc/command.ucls | 89 ++ etc/command.urm.puml | 58 + etc/commander.urm.png | Bin 0 -> 322274 bytes etc/commander.urm.puml | 329 +++++ etc/composite.urm.png | Bin 0 -> 35715 bytes etc/composite.urm.puml | 41 + etc/converter.png | Bin 0 -> 19389 bytes etc/converter.urm.puml | 50 + etc/cqrs.png | Bin 0 -> 105666 bytes etc/cqrs.ucls | 115 ++ etc/cqrs.urm.puml | 134 ++ etc/dao.png | Bin 0 -> 39783 bytes etc/dao.ucls | 75 ++ etc/dao.urm.puml | 68 + etc/data-bus.urm.png | Bin 0 -> 61121 bytes etc/data-bus.urm.puml | 82 ++ etc/data-locality.urm.png | Bin 0 -> 68133 bytes etc/data-locality.urm.puml | 80 ++ etc/data-mapper.png | Bin 0 -> 40158 bytes etc/data-mapper.ucls | 72 + etc/data-mapper.urm.puml | 43 + etc/data-transfer-object.ucls | 48 + etc/data-transfer-object.urm.png | Bin 0 -> 19132 bytes etc/data-transfer-object.urm.puml | 27 + etc/data/test.txt | 25 + etc/decorator.urm.png | Bin 0 -> 23530 bytes etc/decorator.urm.puml | 32 + etc/delegation.png | Bin 0 -> 25260 bytes etc/delegation.ucls | 83 ++ etc/delegation.urm.puml | 39 + etc/dependency-injection.png | Bin 0 -> 22493 bytes etc/dependency-injection.ucls | 141 ++ etc/dependency-injection.urm.puml | 57 + etc/dirty-flag.png | Bin 0 -> 9192 bytes etc/dirty-flag.ucls | 45 + etc/dirty-flag.urm.puml | 25 + etc/double-buffer.urm.png | Bin 0 -> 35073 bytes etc/double-buffer.urm.puml | 45 + etc/double-checked-locking.png | Bin 0 -> 7011 bytes etc/double-checked-locking.ucls | 42 + etc/double-checked-locking.urm.puml | 22 + etc/double-dispatch.png | Bin 0 -> 32364 bytes etc/double-dispatch.ucls | 84 ++ etc/double-dispatch.urm.puml | 74 ++ etc/double_checked_locking_1.png | Bin 0 -> 11954 bytes etc/eda.png | Bin 0 -> 58476 bytes etc/eda.ucls | 184 +++ etc/eip-aggregator.urm.puml | 14 + etc/eip-message-channel.urm.puml | 9 + etc/eip-publish-subscribe.urm.puml | 9 + etc/eip-splitter.urm.puml | 8 + etc/eip-wire-tap.urm.puml | 8 + etc/event-aggregator.urm.puml | 74 ++ etc/event-asynchronous.png | Bin 0 -> 44029 bytes etc/event-asynchronous.ucls | 104 ++ etc/event-asynchronous.urm.puml | 70 + etc/event-driven-architecture.urm.puml | 64 + etc/event-queue.urm.puml | 38 + etc/event-sourcing.png | Bin 0 -> 60339 bytes etc/event-sourcing.ucls | 123 ++ etc/event-sourcing.urm.puml | 107 ++ etc/execute-around.png | Bin 0 -> 4588 bytes etc/execute-around.ucls | 28 + etc/execute-around.urm.puml | 14 + etc/extension-objects.urm.puml | 2 + etc/extension_obj.png | Bin 0 -> 38018 bytes etc/extension_obj.ucls | 180 +++ etc/facade.urm.png | Bin 0 -> 62013 bytes etc/facade.urm.puml | 60 + etc/factory-kit.png | Bin 0 -> 37570 bytes etc/factory-kit.ucls | 10 + etc/factory-kit.urm.puml | 46 + etc/factory-method.urm.png | Bin 0 -> 53024 bytes etc/factory-method.urm.puml | 56 + etc/factory.urm.png | Bin 0 -> 25438 bytes etc/factory.urm.puml | 35 + etc/feature-toggle.png | Bin 0 -> 55425 bytes etc/feature-toggle.ucls | 111 ++ etc/feature-toggle.urm.puml | 48 + etc/filterer.png | Bin 0 -> 130820 bytes etc/filterer.urm.puml | 96 ++ etc/fluentinterface.png | Bin 0 -> 83424 bytes etc/fluentinterface.ucls | 100 ++ etc/fluentinterface.urm.puml | 72 + etc/flux.png | Bin 0 -> 62348 bytes etc/flux.ucls | 232 ++++ etc/flux.urm.puml | 117 ++ etc/flyweight.urm.png | Bin 0 -> 54844 bytes etc/flyweight.urm.puml | 65 + etc/front-controller.png | Bin 0 -> 27672 bytes etc/front-controller.ucls | 143 ++ etc/front-controller.urm.puml | 53 + etc/game-loop.urm.png | Bin 0 -> 57585 bytes etc/game-loop.urm.puml | 63 + etc/gcf-black.png | Bin 0 -> 7651 bytes etc/guarded-suspension.png | Bin 0 -> 10318 bytes etc/guarded-suspension.ucls | 22 + etc/guarded-suspension.urm.puml | 15 + etc/half-sync-half-async.png | Bin 0 -> 32866 bytes etc/half-sync-half-async.ucls | 77 ++ etc/half-sync-half-async.urm.puml | 33 + etc/hexagonal.png | Bin 0 -> 148602 bytes etc/hexagonal.ucls | 280 ++++ etc/hexagonal.urm.puml | 305 +++++ etc/intercepting-filter.png | Bin 0 -> 75351 bytes etc/intercepting-filter.ucls | 228 ++++ etc/intercepting-filter.urm.puml | 88 ++ etc/interpreter.png | Bin 0 -> 27047 bytes etc/interpreter.ucls | 121 ++ etc/interpreter.urm.puml | 51 + etc/interpreter_1.png | Bin 0 -> 46272 bytes etc/iterator.png | Bin 0 -> 26228 bytes etc/iterator.ucls | 94 ++ etc/iterator.urm.puml | 85 ++ etc/iterator_1.png | Bin 0 -> 53045 bytes etc/kubeless-logos-black.png | Bin 0 -> 8939 bytes etc/layers.png | Bin 0 -> 97428 bytes etc/layers.ucls | 256 ++++ etc/layers.urm.puml | 136 ++ etc/lazy-loading.png | Bin 0 -> 11671 bytes etc/lazy-loading.ucls | 66 + etc/lazy-loading.urm.puml | 40 + etc/leader-election.urm.png | Bin 0 -> 173701 bytes etc/leader-election.urm.puml | 120 ++ etc/leader-followers.png | Bin 0 -> 49302 bytes etc/leader-followers.urm.puml | 54 + etc/marker.urm.puml | 2 + etc/master-worker-pattern.urm.png | Bin 0 -> 103285 bytes etc/master-worker-pattern.urm.puml | 78 ++ etc/mediator.png | Bin 0 -> 36948 bytes etc/mediator.ucls | 131 ++ etc/mediator.urm.puml | 69 + etc/mediator_1.png | Bin 0 -> 59727 bytes etc/memento.png | Bin 0 -> 22492 bytes etc/memento.ucls | 70 + etc/memento.urm.puml | 49 + etc/message-channel.png | Bin 0 -> 47216 bytes etc/message-channel.ucls | 320 +++++ etc/model-view-controller.png | Bin 0 -> 18130 bytes etc/model-view-controller.ucls | 53 + etc/model-view-controller.urm.puml | 70 + etc/model-view-presenter.png | Bin 0 -> 41786 bytes etc/model-view-presenter.ucls | 121 ++ etc/model-view-presenter.urm.puml | 90 ++ etc/model-view-presenter_1.png | Bin 0 -> 103398 bytes etc/model-view-viewmodel.png | Bin 0 -> 40539 bytes etc/model-view-viewmodel.urm.puml | 43 + etc/model.png | Bin 0 -> 23221 bytes etc/model.ucls | 36 + etc/module.png | Bin 0 -> 18027 bytes etc/module.ucls | 69 + etc/module.urm.puml | 43 + etc/monad.png | Bin 0 -> 32962 bytes etc/monad.ucls | 54 + etc/monad.urm.puml | 36 + etc/monostate.png | Bin 0 -> 16526 bytes etc/monostate.urm.puml | 32 + etc/multiton.png | Bin 0 -> 10637 bytes etc/multiton.ucls | 44 + etc/multiton.urm.puml | 43 + etc/mute-idiom.png | Bin 0 -> 18505 bytes etc/mute-idiom.ucls | 71 + etc/mute-idiom.urm.puml | 24 + etc/naked-objects.png | Bin 0 -> 75022 bytes etc/naked-objects.ucls | 162 +++ etc/naked-objects.urm.puml | 2 + etc/null-object.png | Bin 0 -> 14069 bytes etc/null-object.ucls | 69 + etc/null-object.urm.puml | 41 + etc/object-mother.png | Bin 0 -> 19705 bytes etc/object-mother.ucls | 56 + etc/object-mother.urm.puml | 45 + etc/object-pool.png | Bin 0 -> 8877 bytes etc/object-pool.ucls | 41 + etc/object-pool.urm.puml | 30 + etc/observer.png | Bin 0 -> 18867 bytes etc/observer.ucls | 87 ++ etc/observer.urm.puml | 82 ++ etc/observer_1.png | Bin 0 -> 32766 bytes etc/observer_with_generics.png | Bin 0 -> 104313 bytes etc/openwhisk-black.png | Bin 0 -> 5722 bytes etc/page-object.png | Bin 0 -> 49696 bytes etc/page-object.ucls | 10 + etc/page-object.urm.puml | 2 + etc/parameter-object.png | Bin 0 -> 182925 bytes etc/parameter-object.urm.puml | 52 + etc/partial-response.ucls | 65 + etc/partial-response.urm.png | Bin 0 -> 27781 bytes etc/partial-response.urm.puml | 31 + etc/pipeline.urm.png | Bin 0 -> 31882 bytes etc/pipeline.urm.puml | 36 + etc/poison-pill.png | Bin 0 -> 15833 bytes etc/poison-pill.ucls | 92 ++ etc/poison-pill.urm.puml | 71 + etc/priority-queue.urm.png | Bin 0 -> 52777 bytes etc/priority-queue.urm.puml | 54 + etc/private-class-data.png | Bin 0 -> 10791 bytes etc/private-class-data.ucls | 45 + etc/private-class-data.urm.puml | 36 + etc/producer-consumer.png | Bin 0 -> 27122 bytes etc/producer-consumer.ucls | 74 ++ etc/producer-consumer.urm.puml | 40 + etc/promise.png | Bin 0 -> 59210 bytes etc/promise.ucls | 111 ++ etc/promise.urm.puml | 79 ++ etc/property.png | Bin 0 -> 20016 bytes etc/property.ucls | 70 + etc/property.urm.puml | 54 + etc/prototype.urm.png | Bin 0 -> 81144 bytes etc/prototype.urm.puml | 105 ++ etc/proxy.urm.png | Bin 0 -> 28797 bytes etc/proxy.urm.puml | 32 + etc/publish-subscribe.png | Bin 0 -> 27741 bytes etc/publish-subscribe.ucls | 218 +++ etc/queue-load-leveling.gif | Bin 0 -> 15062 bytes etc/queue-load-leveling.ucls | 86 ++ etc/queue-load-leveling.urm.puml | 44 + etc/reactor.png | Bin 0 -> 125804 bytes etc/reactor.ucls | 235 ++++ etc/reactor.urm.puml | 155 +++ etc/reader-writer-lock.png | Bin 0 -> 39623 bytes etc/reader-writer-lock.ucls | 86 ++ etc/reader-writer-lock.urm.puml | 65 + etc/registry.png | Bin 0 -> 16875 bytes etc/registry.urm.puml | 21 + etc/repository.png | Bin 0 -> 55254 bytes etc/repository.ucls | 70 + etc/repository.urm.puml | 56 + ...resource-acquisition-is-initialization.png | Bin 0 -> 3760 bytes ...esource-acquisition-is-initialization.ucls | 30 + ...rce-acquisition-is-initialization.urm.puml | 19 + etc/retry.png | Bin 0 -> 52004 bytes etc/retry.urm.puml | 54 + etc/role-object.urm.png | Bin 0 -> 64455 bytes etc/role-object.urm.puml | 60 + etc/saga.urm.png | Bin 0 -> 273181 bytes etc/saga.urm.puml | 222 ++++ etc/separated-interface.urm.puml | 36 + etc/sequencer.gif | Bin 0 -> 2298 bytes etc/servant-pattern.png | Bin 0 -> 30103 bytes etc/servant-pattern.ucls | 79 ++ etc/servant.urm.puml | 56 + etc/serverless.urm.png | Bin 0 -> 219522 bytes etc/serverless.urm.puml | 138 ++ etc/service-layer.png | Bin 0 -> 89966 bytes etc/service-layer.ucls | 250 ++++ etc/service-layer.urm.puml | 159 +++ etc/service-locator.png | Bin 0 -> 16511 bytes etc/service-locator.ucls | 79 ++ etc/service-locator.urm.puml | 41 + etc/sharding.urm.png | Bin 0 -> 63822 bytes etc/sharding.urm.puml | 71 + etc/singleton.urm.png | Bin 0 -> 46739 bytes etc/singleton.urm.puml | 44 + etc/spatial-partition.urm.png | Bin 0 -> 102875 bytes etc/spatial-partition.urm.puml | 72 + etc/special-case.urm.puml | 119 ++ etc/special_case_urm.png | Bin 0 -> 459244 bytes etc/specification.png | Bin 0 -> 49425 bytes etc/specification.ucls | 212 +++ etc/specification.urm.puml | 177 +++ etc/spotinst-logos-black-small.png | Bin 0 -> 5412 bytes etc/state.urm.puml | 39 + etc/state_urm.png | Bin 0 -> 34673 bytes etc/static-content-hosting.drawio | 1 + etc/static-content-hosting.png | Bin 0 -> 88049 bytes etc/step-builder.png | Bin 0 -> 76038 bytes etc/step-builder.ucls | 181 +++ etc/step-builder.urm.puml | 91 ++ etc/strangler.png | Bin 0 -> 77937 bytes etc/strangler.puml | 61 + etc/strangler.urm.puml | 61 + etc/strategy.urm.puml | 53 + etc/strategy_urm.png | Bin 0 -> 143387 bytes etc/subclass-sandbox.urm.png | Bin 0 -> 22259 bytes etc/subclass-sandbox.urm.puml | 27 + etc/template-method.urm.puml | 39 + etc/template_method_urm.png | Bin 0 -> 36470 bytes etc/thread-pool.urm.puml | 37 + etc/thread_pool_urm.png | Bin 0 -> 30120 bytes etc/throttling.urm.puml | 47 + etc/throttling_urm.png | Bin 0 -> 53754 bytes etc/tls.png | Bin 0 -> 34509 bytes etc/tls.ucls | 79 ++ etc/tls.urm.puml | 25 + etc/tolerant-reader.urm.puml | 39 + etc/tolerant_reader_urm.png | Bin 0 -> 46129 bytes etc/trampoline.urm.png | Bin 0 -> 15316 bytes etc/trampoline.urm.puml | 18 + etc/transaction-script.png | Bin 0 -> 66480 bytes etc/transaction-script.urm.puml | 65 + etc/twin.png | Bin 0 -> 29682 bytes etc/twin.ucls | 79 ++ etc/twin.urm.puml | 27 + etc/typeobjectpattern.urm.png | Bin 0 -> 67712 bytes etc/typeobjectpattern.urm.puml | 72 + etc/unit-of-work.ucls | 68 + etc/unit-of-work.urm.png | Bin 0 -> 40804 bytes etc/unit-of-work.urm.puml | 48 + etc/update-method.urm.png | Bin 0 -> 39843 bytes etc/update-method.urm.puml | 51 + etc/value-object.png | Bin 0 -> 5025 bytes etc/value-object.ucls | 19 + etc/value-object.urm.puml | 22 + etc/version-number.urm.png | Bin 0 -> 22183 bytes etc/version-number.urm.puml | 32 + etc/visitor.png | Bin 0 -> 22790 bytes etc/visitor.ucls | 114 ++ etc/visitor.urm.puml | 60 + etc/visitor_1.png | Bin 0 -> 47078 bytes etc/webtask-small-grayscale.png | Bin 0 -> 8420 bytes etc/wiretap.gif | Bin 0 -> 3067 bytes extract.sh | 9 + parse.sh | 13 + patterns.md | 1171 ++++++++++------- 380 files changed, 16714 insertions(+), 462 deletions(-) create mode 100644 etc/Bass-Drum-1.aif create mode 100644 etc/Bass-Drum-1.wav create mode 100644 etc/Closed-Hi-Hat-1.aif create mode 100644 etc/Closed-Hi-Hat-1.wav create mode 100644 etc/Converter.ucls create mode 100644 etc/MarkerDiagram.png create mode 100644 etc/MarkerDiagram.ucls create mode 100644 etc/MonoState.ucls create mode 100644 etc/ServiceDiagram.png create mode 100644 etc/StateDiagram.png create mode 100644 etc/abstract-document.png create mode 100644 etc/abstract-document.ucls create mode 100644 etc/abstract-document.urm.puml create mode 100644 etc/abstract-factory.urm.png create mode 100644 etc/abstract-factory.urm.puml create mode 100644 etc/active-object.urm.PNG create mode 100644 etc/active-object.urm.puml create mode 100644 etc/acyclic-visitor.png create mode 100644 etc/acyclic-visitor.urm.puml create mode 100644 etc/adapter.urm.png create mode 100644 etc/adapter.urm.puml create mode 100644 etc/aggregator-microservices.urm.puml create mode 100644 etc/aggregator.gif create mode 100644 etc/ambassador.urm.png create mode 100644 etc/ambassador.urm.puml create mode 100644 etc/api-gateway.png create mode 100644 etc/api-gateway.ucls create mode 100644 etc/api-gateway.urm.puml create mode 100644 etc/arrange-act-assert.urm.puml create mode 100644 etc/async-method-invocation.png create mode 100644 etc/async-method-invocation.ucls create mode 100644 etc/async-method-invocation.urm.puml create mode 100644 etc/aws-black.png create mode 100644 etc/azure-black.png create mode 100644 etc/balking.png create mode 100644 etc/balking.ucls create mode 100644 etc/balking.urm.puml create mode 100644 etc/bridge.urm.png create mode 100644 etc/bridge.urm.puml create mode 100644 etc/bst.jpg create mode 100644 etc/builder.urm.png create mode 100644 etc/builder.urm.puml create mode 100644 etc/business-delegate.urm.png create mode 100644 etc/business-delegate.urm.puml create mode 100644 etc/bytecode.urm.png create mode 100644 etc/bytecode.urm.puml create mode 100644 etc/caching.png create mode 100644 etc/caching.ucls create mode 100644 etc/caching.urm.puml create mode 100644 etc/callback.png create mode 100644 etc/callback.ucls create mode 100644 etc/callback.urm.puml create mode 100644 etc/chain.urm.png create mode 100644 etc/chain.urm.puml create mode 100644 etc/circuit-breaker.urm.png create mode 100644 etc/circuit-breaker.urm.puml create mode 100644 etc/class_diagram.png create mode 100644 etc/classes.png create mode 100644 etc/classes.ucls create mode 100644 etc/collection-pipeline.png create mode 100644 etc/collection-pipeline.ucls create mode 100644 etc/collection-pipeline.urm.puml create mode 100644 etc/combinator.urm.png create mode 100644 etc/combinator.urm.puml create mode 100644 etc/command.png create mode 100644 etc/command.ucls create mode 100644 etc/command.urm.puml create mode 100644 etc/commander.urm.png create mode 100644 etc/commander.urm.puml create mode 100644 etc/composite.urm.png create mode 100644 etc/composite.urm.puml create mode 100644 etc/converter.png create mode 100644 etc/converter.urm.puml create mode 100644 etc/cqrs.png create mode 100644 etc/cqrs.ucls create mode 100644 etc/cqrs.urm.puml create mode 100644 etc/dao.png create mode 100644 etc/dao.ucls create mode 100644 etc/dao.urm.puml create mode 100644 etc/data-bus.urm.png create mode 100644 etc/data-bus.urm.puml create mode 100644 etc/data-locality.urm.png create mode 100644 etc/data-locality.urm.puml create mode 100644 etc/data-mapper.png create mode 100644 etc/data-mapper.ucls create mode 100644 etc/data-mapper.urm.puml create mode 100644 etc/data-transfer-object.ucls create mode 100644 etc/data-transfer-object.urm.png create mode 100644 etc/data-transfer-object.urm.puml create mode 100644 etc/data/test.txt create mode 100644 etc/decorator.urm.png create mode 100644 etc/decorator.urm.puml create mode 100644 etc/delegation.png create mode 100644 etc/delegation.ucls create mode 100644 etc/delegation.urm.puml create mode 100644 etc/dependency-injection.png create mode 100644 etc/dependency-injection.ucls create mode 100644 etc/dependency-injection.urm.puml create mode 100644 etc/dirty-flag.png create mode 100644 etc/dirty-flag.ucls create mode 100644 etc/dirty-flag.urm.puml create mode 100644 etc/double-buffer.urm.png create mode 100644 etc/double-buffer.urm.puml create mode 100644 etc/double-checked-locking.png create mode 100644 etc/double-checked-locking.ucls create mode 100644 etc/double-checked-locking.urm.puml create mode 100644 etc/double-dispatch.png create mode 100644 etc/double-dispatch.ucls create mode 100644 etc/double-dispatch.urm.puml create mode 100644 etc/double_checked_locking_1.png create mode 100644 etc/eda.png create mode 100644 etc/eda.ucls create mode 100644 etc/eip-aggregator.urm.puml create mode 100644 etc/eip-message-channel.urm.puml create mode 100644 etc/eip-publish-subscribe.urm.puml create mode 100644 etc/eip-splitter.urm.puml create mode 100644 etc/eip-wire-tap.urm.puml create mode 100644 etc/event-aggregator.urm.puml create mode 100644 etc/event-asynchronous.png create mode 100644 etc/event-asynchronous.ucls create mode 100644 etc/event-asynchronous.urm.puml create mode 100644 etc/event-driven-architecture.urm.puml create mode 100644 etc/event-queue.urm.puml create mode 100644 etc/event-sourcing.png create mode 100644 etc/event-sourcing.ucls create mode 100644 etc/event-sourcing.urm.puml create mode 100644 etc/execute-around.png create mode 100644 etc/execute-around.ucls create mode 100644 etc/execute-around.urm.puml create mode 100644 etc/extension-objects.urm.puml create mode 100644 etc/extension_obj.png create mode 100644 etc/extension_obj.ucls create mode 100644 etc/facade.urm.png create mode 100644 etc/facade.urm.puml create mode 100644 etc/factory-kit.png create mode 100644 etc/factory-kit.ucls create mode 100644 etc/factory-kit.urm.puml create mode 100644 etc/factory-method.urm.png create mode 100644 etc/factory-method.urm.puml create mode 100644 etc/factory.urm.png create mode 100644 etc/factory.urm.puml create mode 100644 etc/feature-toggle.png create mode 100644 etc/feature-toggle.ucls create mode 100644 etc/feature-toggle.urm.puml create mode 100644 etc/filterer.png create mode 100644 etc/filterer.urm.puml create mode 100644 etc/fluentinterface.png create mode 100644 etc/fluentinterface.ucls create mode 100644 etc/fluentinterface.urm.puml create mode 100644 etc/flux.png create mode 100644 etc/flux.ucls create mode 100644 etc/flux.urm.puml create mode 100644 etc/flyweight.urm.png create mode 100644 etc/flyweight.urm.puml create mode 100644 etc/front-controller.png create mode 100644 etc/front-controller.ucls create mode 100644 etc/front-controller.urm.puml create mode 100644 etc/game-loop.urm.png create mode 100644 etc/game-loop.urm.puml create mode 100644 etc/gcf-black.png create mode 100644 etc/guarded-suspension.png create mode 100644 etc/guarded-suspension.ucls create mode 100644 etc/guarded-suspension.urm.puml create mode 100644 etc/half-sync-half-async.png create mode 100644 etc/half-sync-half-async.ucls create mode 100644 etc/half-sync-half-async.urm.puml create mode 100644 etc/hexagonal.png create mode 100644 etc/hexagonal.ucls create mode 100644 etc/hexagonal.urm.puml create mode 100644 etc/intercepting-filter.png create mode 100644 etc/intercepting-filter.ucls create mode 100644 etc/intercepting-filter.urm.puml create mode 100644 etc/interpreter.png create mode 100644 etc/interpreter.ucls create mode 100644 etc/interpreter.urm.puml create mode 100644 etc/interpreter_1.png create mode 100644 etc/iterator.png create mode 100644 etc/iterator.ucls create mode 100644 etc/iterator.urm.puml create mode 100644 etc/iterator_1.png create mode 100644 etc/kubeless-logos-black.png create mode 100644 etc/layers.png create mode 100644 etc/layers.ucls create mode 100644 etc/layers.urm.puml create mode 100644 etc/lazy-loading.png create mode 100644 etc/lazy-loading.ucls create mode 100644 etc/lazy-loading.urm.puml create mode 100644 etc/leader-election.urm.png create mode 100644 etc/leader-election.urm.puml create mode 100644 etc/leader-followers.png create mode 100644 etc/leader-followers.urm.puml create mode 100644 etc/marker.urm.puml create mode 100644 etc/master-worker-pattern.urm.png create mode 100644 etc/master-worker-pattern.urm.puml create mode 100644 etc/mediator.png create mode 100644 etc/mediator.ucls create mode 100644 etc/mediator.urm.puml create mode 100644 etc/mediator_1.png create mode 100644 etc/memento.png create mode 100644 etc/memento.ucls create mode 100644 etc/memento.urm.puml create mode 100644 etc/message-channel.png create mode 100644 etc/message-channel.ucls create mode 100644 etc/model-view-controller.png create mode 100644 etc/model-view-controller.ucls create mode 100644 etc/model-view-controller.urm.puml create mode 100644 etc/model-view-presenter.png create mode 100644 etc/model-view-presenter.ucls create mode 100644 etc/model-view-presenter.urm.puml create mode 100644 etc/model-view-presenter_1.png create mode 100644 etc/model-view-viewmodel.png create mode 100644 etc/model-view-viewmodel.urm.puml create mode 100644 etc/model.png create mode 100644 etc/model.ucls create mode 100644 etc/module.png create mode 100644 etc/module.ucls create mode 100644 etc/module.urm.puml create mode 100644 etc/monad.png create mode 100644 etc/monad.ucls create mode 100644 etc/monad.urm.puml create mode 100644 etc/monostate.png create mode 100644 etc/monostate.urm.puml create mode 100644 etc/multiton.png create mode 100644 etc/multiton.ucls create mode 100644 etc/multiton.urm.puml create mode 100644 etc/mute-idiom.png create mode 100644 etc/mute-idiom.ucls create mode 100644 etc/mute-idiom.urm.puml create mode 100644 etc/naked-objects.png create mode 100644 etc/naked-objects.ucls create mode 100644 etc/naked-objects.urm.puml create mode 100644 etc/null-object.png create mode 100644 etc/null-object.ucls create mode 100644 etc/null-object.urm.puml create mode 100644 etc/object-mother.png create mode 100644 etc/object-mother.ucls create mode 100644 etc/object-mother.urm.puml create mode 100644 etc/object-pool.png create mode 100644 etc/object-pool.ucls create mode 100644 etc/object-pool.urm.puml create mode 100644 etc/observer.png create mode 100644 etc/observer.ucls create mode 100644 etc/observer.urm.puml create mode 100644 etc/observer_1.png create mode 100644 etc/observer_with_generics.png create mode 100644 etc/openwhisk-black.png create mode 100644 etc/page-object.png create mode 100644 etc/page-object.ucls create mode 100644 etc/page-object.urm.puml create mode 100644 etc/parameter-object.png create mode 100644 etc/parameter-object.urm.puml create mode 100644 etc/partial-response.ucls create mode 100644 etc/partial-response.urm.png create mode 100644 etc/partial-response.urm.puml create mode 100644 etc/pipeline.urm.png create mode 100644 etc/pipeline.urm.puml create mode 100644 etc/poison-pill.png create mode 100644 etc/poison-pill.ucls create mode 100644 etc/poison-pill.urm.puml create mode 100644 etc/priority-queue.urm.png create mode 100644 etc/priority-queue.urm.puml create mode 100644 etc/private-class-data.png create mode 100644 etc/private-class-data.ucls create mode 100644 etc/private-class-data.urm.puml create mode 100644 etc/producer-consumer.png create mode 100644 etc/producer-consumer.ucls create mode 100644 etc/producer-consumer.urm.puml create mode 100644 etc/promise.png create mode 100644 etc/promise.ucls create mode 100644 etc/promise.urm.puml create mode 100644 etc/property.png create mode 100644 etc/property.ucls create mode 100644 etc/property.urm.puml create mode 100644 etc/prototype.urm.png create mode 100644 etc/prototype.urm.puml create mode 100644 etc/proxy.urm.png create mode 100644 etc/proxy.urm.puml create mode 100644 etc/publish-subscribe.png create mode 100644 etc/publish-subscribe.ucls create mode 100644 etc/queue-load-leveling.gif create mode 100644 etc/queue-load-leveling.ucls create mode 100644 etc/queue-load-leveling.urm.puml create mode 100644 etc/reactor.png create mode 100644 etc/reactor.ucls create mode 100644 etc/reactor.urm.puml create mode 100644 etc/reader-writer-lock.png create mode 100644 etc/reader-writer-lock.ucls create mode 100644 etc/reader-writer-lock.urm.puml create mode 100644 etc/registry.png create mode 100644 etc/registry.urm.puml create mode 100644 etc/repository.png create mode 100644 etc/repository.ucls create mode 100644 etc/repository.urm.puml create mode 100644 etc/resource-acquisition-is-initialization.png create mode 100644 etc/resource-acquisition-is-initialization.ucls create mode 100644 etc/resource-acquisition-is-initialization.urm.puml create mode 100644 etc/retry.png create mode 100644 etc/retry.urm.puml create mode 100644 etc/role-object.urm.png create mode 100644 etc/role-object.urm.puml create mode 100644 etc/saga.urm.png create mode 100644 etc/saga.urm.puml create mode 100644 etc/separated-interface.urm.puml create mode 100644 etc/sequencer.gif create mode 100644 etc/servant-pattern.png create mode 100644 etc/servant-pattern.ucls create mode 100644 etc/servant.urm.puml create mode 100644 etc/serverless.urm.png create mode 100644 etc/serverless.urm.puml create mode 100644 etc/service-layer.png create mode 100644 etc/service-layer.ucls create mode 100644 etc/service-layer.urm.puml create mode 100644 etc/service-locator.png create mode 100644 etc/service-locator.ucls create mode 100644 etc/service-locator.urm.puml create mode 100644 etc/sharding.urm.png create mode 100644 etc/sharding.urm.puml create mode 100644 etc/singleton.urm.png create mode 100644 etc/singleton.urm.puml create mode 100644 etc/spatial-partition.urm.png create mode 100644 etc/spatial-partition.urm.puml create mode 100644 etc/special-case.urm.puml create mode 100644 etc/special_case_urm.png create mode 100644 etc/specification.png create mode 100644 etc/specification.ucls create mode 100644 etc/specification.urm.puml create mode 100644 etc/spotinst-logos-black-small.png create mode 100644 etc/state.urm.puml create mode 100644 etc/state_urm.png create mode 100644 etc/static-content-hosting.drawio create mode 100644 etc/static-content-hosting.png create mode 100644 etc/step-builder.png create mode 100644 etc/step-builder.ucls create mode 100644 etc/step-builder.urm.puml create mode 100644 etc/strangler.png create mode 100644 etc/strangler.puml create mode 100644 etc/strangler.urm.puml create mode 100644 etc/strategy.urm.puml create mode 100644 etc/strategy_urm.png create mode 100644 etc/subclass-sandbox.urm.png create mode 100644 etc/subclass-sandbox.urm.puml create mode 100644 etc/template-method.urm.puml create mode 100644 etc/template_method_urm.png create mode 100644 etc/thread-pool.urm.puml create mode 100644 etc/thread_pool_urm.png create mode 100644 etc/throttling.urm.puml create mode 100644 etc/throttling_urm.png create mode 100644 etc/tls.png create mode 100644 etc/tls.ucls create mode 100644 etc/tls.urm.puml create mode 100644 etc/tolerant-reader.urm.puml create mode 100644 etc/tolerant_reader_urm.png create mode 100644 etc/trampoline.urm.png create mode 100644 etc/trampoline.urm.puml create mode 100644 etc/transaction-script.png create mode 100644 etc/transaction-script.urm.puml create mode 100644 etc/twin.png create mode 100644 etc/twin.ucls create mode 100644 etc/twin.urm.puml create mode 100644 etc/typeobjectpattern.urm.png create mode 100644 etc/typeobjectpattern.urm.puml create mode 100644 etc/unit-of-work.ucls create mode 100644 etc/unit-of-work.urm.png create mode 100644 etc/unit-of-work.urm.puml create mode 100644 etc/update-method.urm.png create mode 100644 etc/update-method.urm.puml create mode 100644 etc/value-object.png create mode 100644 etc/value-object.ucls create mode 100644 etc/value-object.urm.puml create mode 100644 etc/version-number.urm.png create mode 100644 etc/version-number.urm.puml create mode 100644 etc/visitor.png create mode 100644 etc/visitor.ucls create mode 100644 etc/visitor.urm.puml create mode 100644 etc/visitor_1.png create mode 100644 etc/webtask-small-grayscale.png create mode 100644 etc/wiretap.gif create mode 100644 extract.sh create mode 100644 parse.sh diff --git a/etc/Bass-Drum-1.aif b/etc/Bass-Drum-1.aif new file mode 100644 index 0000000000000000000000000000000000000000..f1eae69db029ffa97252279b94c94930d5f74ad9 GIT binary patch literal 220938 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 z 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ð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%0D|n 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 literal 0 HcmV?d00001 diff --git a/etc/Bass-Drum-1.wav b/etc/Bass-Drum-1.wav new file mode 100644 index 0000000000000000000000000000000000000000..566181d942aa4542f36826d55161845f9ed0ad53 GIT binary patch literal 221080 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
  • 60JcG?;$VvR*l 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%0DPyWASwtTqG(=xxC$ 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 y;eWVa{^sco@Y8mk00;|V + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/etc/MarkerDiagram.png b/etc/MarkerDiagram.png new file mode 100644 index 0000000000000000000000000000000000000000..6ed4f9c567809787d9317733a2e4fe40cbe3284c GIT binary patch literal 6461 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 WzLyy+Lj79=qN54ic(48-^uGXLahsh0 literal 0 HcmV?d00001 diff --git a/etc/MarkerDiagram.ucls b/etc/MarkerDiagram.ucls new file mode 100644 index 000000000000..0f8376e40e23 --- /dev/null +++ b/etc/MarkerDiagram.ucls @@ -0,0 +1,41 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/etc/MonoState.ucls b/etc/MonoState.ucls new file mode 100644 index 000000000000..76b48ad0fa2a --- /dev/null +++ b/etc/MonoState.ucls @@ -0,0 +1,53 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/etc/ServiceDiagram.png b/etc/ServiceDiagram.png new file mode 100644 index 0000000000000000000000000000000000000000..885320a4d9014d18f071638d7075e6987c463fd6 GIT binary patch literal 23591 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 literal 0 HcmV?d00001 diff --git a/etc/abstract-document.png b/etc/abstract-document.png new file mode 100644 index 0000000000000000000000000000000000000000..6bc0b29a4e77680d8eda277c93b97277bbe7193b GIT binary patch literal 96228 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∈MtPMEwTr6eK$ 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 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/etc/abstract-document.urm.puml b/etc/abstract-document.urm.puml new file mode 100644 index 000000000000..9940dc2cfd05 --- /dev/null +++ b/etc/abstract-document.urm.puml @@ -0,0 +1,65 @@ +@startuml +package com.iluwatar.abstractdocument.domain.enums { + enum Property { + + MODEL {static} + + PARTS {static} + + PRICE {static} + + TYPE {static} + + valueOf(name : String) : Property {static} + + values() : Property[] {static} + } +} +package com.iluwatar.abstractdocument.domain { + class Car { + + Car(properties : Map) + } + interface HasModel { + + getModel() : Optional + } + interface HasParts { + + getParts() : Stream + } + interface HasPrice { + + getPrice() : Optional + } + interface HasType { + + getType() : Optional + } + class Part { + + Part(properties : Map) + } +} +package com.iluwatar.abstractdocument { + abstract class AbstractDocument { + - properties : Map + # AbstractDocument(properties : Map) + + children(key : String, constructor : Function, T>) : Stream + + get(key : String) : Object + + put(key : String, value : Object) + + toString() : String + } + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + interface Document { + + children(String, Function, T>) : Stream {abstract} + + get(String) : Object {abstract} + + put(String, Object) {abstract} + } +} +AbstractDocument ..|> Document +Car ..|> HasModel +Car ..|> HasPrice +Car ..|> HasParts +Car --|> AbstractDocument +HasModel --|> Document +HasParts --|> Document +HasPrice --|> Document +HasType --|> Document +Part ..|> HasType +Part ..|> HasModel +Part ..|> HasPrice +Part --|> AbstractDocument +@enduml \ No newline at end of file diff --git a/etc/abstract-factory.urm.png b/etc/abstract-factory.urm.png new file mode 100644 index 0000000000000000000000000000000000000000..836858a2c652f55723cff879d1058248e1d2799c GIT binary patch literal 82368 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 MUHx3vIVCg!0PQSJ00000 literal 0 HcmV?d00001 diff --git a/etc/abstract-factory.urm.puml b/etc/abstract-factory.urm.puml new file mode 100644 index 000000000000..999091ef54f6 --- /dev/null +++ b/etc/abstract-factory.urm.puml @@ -0,0 +1,101 @@ +@startuml +package com.iluwatar.abstractfactory { + class App { + - LOGGER : Logger {static} + - army : Army + - castle : Castle + - king : King + + App() + + createKingdom(factory : KingdomFactory) + + getArmy() : Army + ~ getArmy(factory : KingdomFactory) : Army + + getCastle() : Castle + ~ getCastle(factory : KingdomFactory) : Castle + + getKing() : King + ~ getKing(factory : KingdomFactory) : King + + main(args : String[]) {static} + - setArmy(army : Army) + - setCastle(castle : Castle) + - setKing(king : King) + } + class FactoryMaker { + + FactoryMaker() + + makeFactory(type : KingdomType) : KingdomFactory {static} + } + enum KingdomType { + + ELF {static} + + ORC {static} + + valueOf(name : String) : KingdomType {static} + + values() : KingdomType[] {static} + } + interface Army { + + getDescription() : String {abstract} + } + interface Castle { + + getDescription() : String {abstract} + } + class ElfArmy { + ~ DESCRIPTION : String {static} + + ElfArmy() + + getDescription() : String + } + class ElfCastle { + ~ DESCRIPTION : String {static} + + ElfCastle() + + getDescription() : String + } + class ElfKing { + ~ DESCRIPTION : String {static} + + ElfKing() + + getDescription() : String + } + class ElfKingdomFactory { + + ElfKingdomFactory() + + createArmy() : Army + + createCastle() : Castle + + createKing() : King + } + interface King { + + getDescription() : String {abstract} + } + interface KingdomFactory { + + createArmy() : Army {abstract} + + createCastle() : Castle {abstract} + + createKing() : King {abstract} + } + class OrcArmy { + ~ DESCRIPTION : String {static} + + OrcArmy() + + getDescription() : String + } + class OrcCastle { + ~ DESCRIPTION : String {static} + + OrcCastle() + + getDescription() : String + } + class OrcKing { + ~ DESCRIPTION : String {static} + + OrcKing() + + getDescription() : String + } + class OrcKingdomFactory { + + OrcKingdomFactory() + + createArmy() : Army + + createCastle() : Castle + + createKing() : King + } +} +KingdomType ..+ FactoryMaker +App --> "-castle" Castle +FactoryMaker ..+ App +App --> "-king" King +App --> "-army" Army +ElfArmy ..|> Army +ElfCastle ..|> Castle +ElfKing ..|> King +ElfKingdomFactory ..|> KingdomFactory +OrcArmy ..|> Army +OrcCastle ..|> Castle +OrcKing ..|> King +OrcKingdomFactory ..|> KingdomFactory +@enduml \ No newline at end of file diff --git a/etc/active-object.urm.PNG b/etc/active-object.urm.PNG new file mode 100644 index 0000000000000000000000000000000000000000..c14f66144ee297261111c1c05529c5d00ebe393e GIT binary patch literal 19466 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

    0AXR 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 LOQT8y&)EM0Zf;=R literal 0 HcmV?d00001 diff --git a/etc/balking.png b/etc/balking.png new file mode 100644 index 0000000000000000000000000000000000000000..f409eaacbb951b01f4bbeb5b6b6f51bed1a86179 GIT binary patch literal 21427 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 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/etc/balking.urm.puml b/etc/balking.urm.puml new file mode 100644 index 000000000000..191fd350bcd8 --- /dev/null +++ b/etc/balking.urm.puml @@ -0,0 +1,30 @@ +@startuml +package com.iluwatar.balking { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + interface DelayProvider { + + executeAfterDelay(long, TimeUnit, Runnable) {abstract} + } + class WashingMachine { + - LOGGER : Logger {static} + - delayProvider : DelayProvider + - washingMachineState : WashingMachineState + + WashingMachine() + + WashingMachine(delayProvider : DelayProvider) + + endOfWashing() + + getWashingMachineState() : WashingMachineState + + wash() + } + enum WashingMachineState { + + ENABLED {static} + + WASHING {static} + + valueOf(name : String) : WashingMachineState {static} + + values() : WashingMachineState[] {static} + } +} +WashingMachine --> "-washingMachineState" WashingMachineState +WashingMachine --> "-delayProvider" DelayProvider +@enduml \ No newline at end of file diff --git a/etc/bridge.urm.png b/etc/bridge.urm.png new file mode 100644 index 0000000000000000000000000000000000000000..785585bf8163e4802bf9b84f03e3c1bb172dd695 GIT binary patch literal 43639 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 Ae*gdg literal 0 HcmV?d00001 diff --git a/etc/bridge.urm.puml b/etc/bridge.urm.puml new file mode 100644 index 000000000000..d5d6a38a91d9 --- /dev/null +++ b/etc/bridge.urm.puml @@ -0,0 +1,58 @@ +@startuml +package com.iluwatar.bridge { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + interface Enchantment { + + apply() {abstract} + + onActivate() {abstract} + + onDeactivate() {abstract} + } + class FlyingEnchantment { + - LOGGER : Logger {static} + + FlyingEnchantment() + + apply() + + onActivate() + + onDeactivate() + } + class Hammer { + - LOGGER : Logger {static} + - enchantment : Enchantment + + Hammer(enchantment : Enchantment) + + getEnchantment() : Enchantment + + swing() + + unwield() + + wield() + } + class SoulEatingEnchantment { + - LOGGER : Logger {static} + + SoulEatingEnchantment() + + apply() + + onActivate() + + onDeactivate() + } + class Sword { + - LOGGER : Logger {static} + - enchantment : Enchantment + + Sword(enchantment : Enchantment) + + getEnchantment() : Enchantment + + swing() + + unwield() + + wield() + } + interface Weapon { + + getEnchantment() : Enchantment {abstract} + + swing() {abstract} + + unwield() {abstract} + + wield() {abstract} + } +} +Sword --> "-enchantment" Enchantment +Hammer --> "-enchantment" Enchantment +FlyingEnchantment ..|> Enchantment +Hammer ..|> Weapon +SoulEatingEnchantment ..|> Enchantment +Sword ..|> Weapon +@enduml \ No newline at end of file diff --git a/etc/bst.jpg b/etc/bst.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f7ed6af8271ef23c3fd86160a162b6c71e630ff5 GIT binary patch literal 77452 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

    D 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 E9~Pz?ng9R* literal 0 HcmV?d00001 diff --git a/etc/builder.urm.puml b/etc/builder.urm.puml new file mode 100644 index 000000000000..43d595a176fc --- /dev/null +++ b/etc/builder.urm.puml @@ -0,0 +1,100 @@ +@startuml +package com.iluwatar.builder { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + enum Armor { + + CHAIN_MAIL {static} + + CLOTHES {static} + + LEATHER {static} + + PLATE_MAIL {static} + - title : String + + toString() : String + + valueOf(name : String) : Armor {static} + + values() : Armor[] {static} + } + enum HairColor { + + BLACK {static} + + BLOND {static} + + BROWN {static} + + RED {static} + + WHITE {static} + + toString() : String + + valueOf(name : String) : HairColor {static} + + values() : HairColor[] {static} + } + enum HairType { + + BALD {static} + + CURLY {static} + + LONG_CURLY {static} + + LONG_STRAIGHT {static} + + SHORT {static} + - title : String + + toString() : String + + valueOf(name : String) : HairType {static} + + values() : HairType[] {static} + } + class Hero { + - armor : Armor + - hairColor : HairColor + - hairType : HairType + - name : String + - profession : Profession + - weapon : Weapon + - Hero(builder : Builder) + + getArmor() : Armor + + getHairColor() : HairColor + + getHairType() : HairType + + getName() : String + + getProfession() : Profession + + getWeapon() : Weapon + + toString() : String + } + class Builder { + - armor : Armor + - hairColor : HairColor + - hairType : HairType + - name : String + - profession : Profession + - weapon : Weapon + + Builder(profession : Profession, name : String) + + build() : Hero + + withArmor(armor : Armor) : Builder + + withHairColor(hairColor : HairColor) : Builder + + withHairType(hairType : HairType) : Builder + + withWeapon(weapon : Weapon) : Builder + } + enum Profession { + + MAGE {static} + + PRIEST {static} + + THIEF {static} + + WARRIOR {static} + + toString() : String + + valueOf(name : String) : Profession {static} + + values() : Profession[] {static} + } + enum Weapon { + + AXE {static} + + BOW {static} + + DAGGER {static} + + SWORD {static} + + WARHAMMER {static} + + toString() : String + + valueOf(name : String) : Weapon {static} + + values() : Weapon[] {static} + } +} +Hero --> "-profession" Profession +Builder ..+ Hero +Hero --> "-armor" Armor +Builder --> "-hairColor" HairColor +Builder --> "-weapon" Weapon +Builder --> "-hairType" HairType +Hero --> "-hairColor" HairColor +Builder --> "-profession" Profession +Hero --> "-weapon" Weapon +Hero --> "-hairType" HairType +Builder --> "-armor" Armor +@enduml \ No newline at end of file diff --git a/etc/business-delegate.urm.png b/etc/business-delegate.urm.png new file mode 100644 index 0000000000000000000000000000000000000000..4dca6c263b99ddc3898218250c4da67fc6d71314 GIT binary patch literal 50060 zcmaHzbzE0V*XSwf{L$Sd64FR_Hv$5JAl;30m(n2JjndsMC8TQUXA=q(wA?9D|q;{R>Vl->|8Rst*i3ACAOwJ#aw>kY1()8UB6%7#z z!*Mk0IiGk{F4C4tq{+o&yH4x-M5&Z`m(s6qFW%iAYa zPdH?vbYE}iLlDqsJ@QTO(@g3uC!A}PZUT1?s!5*Zrmn?S#UsVoZR$8N`O<-B-tj5d z=*KMnf0ur#qB3oLb?p0&S5$}Bdq!rqs@*zvD_=glk3}2q z+x!%+dPf*qRNvqDyp^?@~%Hww(Z}yxaaYc z_CG#<@m<&W*LKFXf>ZaJI!-sTq$FQpyKp1XW)i9Rg3GfwUPzR6Z7462 zzE^RYUn?#y@ z7Zj8ql&plP#vA>emk8Rp{dj#LQmPs_Y@E2bm{>auXZosDy^E1giC$Y*^@R`-C-%-9 zMIb|-!QjDBGrTRv%zZk>;`&M7DCsBZ{${(0sT*_?{@$YC{kgA~)7WTc3bWH)%7Wn( z1Gc{i1!h=lR~R=1CL$b6tbBIj!#}7hM3_avKP2@1bpn3hLFJ}%v^kN-3kQ?amBwSY zi5DPJjN9}TVlFI&2qzXO=y^8I4Ck-HBqS-XS)rd%=NlqYj9yq+m?s@wsEY`bqv`cF zvD3f<7AA-NWPfR?yPJxdI&jfXq!?06i`ZL4!N7nx*IjM$8J$cZIW;vkG4X6|5c?T6 zOb!u)vV3|*Mh?1oC_3(KiNxj)Oy?DKCIUW38jazuF8@Ue_%=c0&Kk3^xA?4!O->sF z12Qr3UyGENTHK;XgG7qqi)ovBlApeIBtv#Wd`S|(;$`{BqnI|!OYwVyok5P+BVS+N znE2ja34+vCkJGmgkH8Lnjhn78=-$PZ2TT=j z#^LVf5*ix%`fN8a2T5pMtQgPzTU4u42iwlp^rnLN5k7|gn?@(4u0$Q1H^ zX8l34jHn8wi@X~=o^wYlpSUw!L9P*Q{hp6XL_;H?rKP2$gpnjEBO{}zXd{E)El5a~ z`^agz)4#@aq`I~?=!4kRudhYMOnMT$_c29p4u32or{5fp2^*^yI%BE1BHO<}KqY`m z!bLak3V3AS9SP^J+it$au*T7|5_64!9Ka-oOXCumUtZ$%0`7c&iB&CMrondM=H}*= zx#P`+gV%7d3iHtiS_AJ>Tnqo7pOfg(#-^w7cgF9++dNLUvhia4G#h;HeX8*%AlTU0 z<}(yxG-e~IT<>t1;K?Y^T!l!~F(cy=61~nB+}4WNj`W)xgK;D#%hd|xq*Av;J*LZF z#;|AGsOc|xH%p{hVag1U^N+ie=MatxA>5-9WBoritu@t?ZaWV!; zg1t;JU#Vf9NGfn*;{7crf#rj;($eg0Y$77$HrhWD%BRI=(epzz%183bM-qH<0G0X` z*oDkTx;Bf=lsHTzwCEj~+I;6@$KH%XR|eCgY6x6SKFa#HDa7{YC7!h zN5)6-Tc5-^L$f|7u_ELIz@a8D+j)3ALnWeshK@C+e(QL?_cDx>O^x!D&+Edzu=f}< zQB2rdX_CTF;{2*uR>U8@6+c@wIukW2#;SLrp4Gn=s07W`aHLlY7@y3{Y*5r!- zeLf9{PrdB|k&oE?FpgfYpP!$?h~JmNK_s6jQhv=sL`HtuV?S)Ms7Is3H?0n<@Fay3 z{n!i!&Zbj&F=MEYV#^GCZ@F$--H+)=o*1YU?r<4Z01Xl=eNh9yBYby3{a~3S?q49l z&<)eps$Tb_8wtDa5LAg!2W5@N(+Y3S8rf`z8f9(z&T2}42UA(6FZ|FW4mOcb&8y^ zdTfx0NpYY3jP0zuUk~xUc!Lg%;yZ1LIte+bw>XS2!axmVeAIx>-zY;^FB(uVS0mtb zs%^e=U%aR?l0+>0^bS9?oD(j?X_vhb}$)X(!J-!Ytb z{709vry;0>-5X}2kFM6%jDPq~O5cT*>$f2XJ|-|b@OQkuI&D=hsga0+fq$10@Q%yl zWOM(K9~sZ!ljlJRFA;@$kK2%sXx^rGTED~7)D`0Bb*Scg`ZRWjX%cd2)vK?5SMwEaB(mg}AR)zjr@EI_Xa=oUw9y2|@Nl2K=%Vy_T zp-gOS6iH0evObXcZ(_Y?);(JvNlOVZ)3YbyFp1s-J`A%-$iw@7XK{1&Kyo_* zx8wHgyTUqQ(#;>8#A$77%P}V>Cx0+hj-!0qlmNGVQ&UsSq@2L9c2D}~${DwP@R z(M&?1QjU!Cu{>k^iMT8YEEXS|$l+6(j2TCvUlB^B@<{3H>&IlRtsy|OOPaBNOB@^S z@C;pj{QN`0!9vT!ms!-CAc=Y?1;V2}=ph$%g^t)dTuW1v|J$%pBo@t50_TG7wHDaq zciNJSF4Y)zIZ{CZfu;R(^(>+^jK_iTCSG>Ua1q*{r> zO@+d_qZC6tk>gVf3;lI^XCnH)dkzjJ@8-YB5 zgOnwbg3k|R_qsSJZE}VoSQSG+eD?ez86`&txnVpdoK`PjgQ3cpyW!`i_rhRF9?s# zbw~U4>s2&j?&a4kLC+rYG;`=sbW-*&H`9U-w_$_fg79KuV^x7Ff)BsEx(W#mrKh8d zyT=ow&1ozlO_zg^9Z#p2%I{Vl9gPttr=WnEf#k1(e(`O{ z3EYoVjF=J_4bnlx9w|LrGSQz(@&j`_AGIo?q$x08RDsBAPBbpHxkw6=!`Ycps>>YS zb50AgO2bWxoIBu2I^2)f+dR)R1>ECyN!%tOa4`NN#?VNo!uK~$mX=$W#~Y%m)fubh zq|ENen-(5=$dGUixFrD}DK0}eF+|7~KC{kAKe;c7un)-^&3C@Nxd})kKWqdMRjiEU zfvp$vw;(J;N}1v;K~L8=Z+HigB9tCRQ)K3Av6S@CgMx%l>Smt40FoNOqnT9B5?WYV z5@u&-fBIDQqK!(`TwQ)y>1U&GtW5sm(WpPvBt)Wqxy~4@n5d{I8z-Odoj?X7lZt$d z3~sEsZ0(rorp5YA-D5EukSbHfI@0JsIPFY~jg3bQK2lA>PeQ~ErG~!U-XXN7LNvcK z4OH)5_t{Nw_ZDolPsESz9D1L#q>M&OtVc-5dzn2sJ3k-0wECtDtF*6yJnQaVOdHbq z(bK!f>J-uW1eJ(~%een4hM;3SKK20r%PS=315}5tJGTowS7{n{T?q56koUw?nXc2F z&goZ?ZWy)u!FFMBW>s#E#X^!x56f(u{#RKh+2m?LWzhAcxzY+=*YF4o1M}cJmgjM^ zY56d)v*00k_8vt->X!QCmf-UnC7o`$!xzUQ*ornIN^Yj^j~WC_KTt(n%Z3kP9C zDy`wwy#WD89UNo+WUJ65#DtyNq~Rm}b(Ha<>AumY$VfOS$(*CsrO!?LZ?e5j3uvfWe zmi=6KMzqjS`r^f7Vz%)dVor>yvY2dIF3TBaJ>ICB);CW`OZ5a@gQM34vp9p zWO>MU`Wlx*@-S1W2SG6Ctt4Opp%hOR4H^!m^ zcrYP`r0kr5Md>?Aat77LVuA3ZD*id*Ep6^jFcGi&&luJ6?F-~^DdWVO3QtbkaGP_r5p0{$;XCuJi?-?sY!5SG<^V=f}Dd zuKfgTndX?^w|B*`sRgS-Qo=PGT3 zX>_VRPA3mnJN!iU_x50sin{S21YG%-L+@rjOLr1o{ywHmraEP zPEPunCT9;9yMX#e7OL$AF@oozF zgyzXIsw|=00tQ%aV-<(!@iqIc5LYWTe5Ja`HfHa<8U=I=HrwuI+&FVtk1O)TMAM!S z_i|mH!0TdK%yX-6ANn?e4y8MMNO=`Gg&m9#o{IId>eh40svAME!}^erJjT{6G5S_x z_AxzLUc!yO;MmS8TW;+oN~lhpncOGz50X}ot}yXV>_hVP|5`vdO-p(%mZuHX**i}R zmtxW*# zHn%G3;djiRXOxq2vD0y%liWxJukPL>ovX?(wkx_imkPM;B~MpG)6-ZpzHHWTJPJLh zB_p#v-}~f$(Ad&4oOX^o`wkN5wjXD>Jy{~2B_xPiu9SsNSz$a?k@dV#p+qrleZH0O z7?>O|d;{-q{2MLu7P4&~N_ThiGDMe1e=P~Jz>~EeR9U63h1nTmp-k!UM&BlJeulmvy`A zz`)sCiS!ysn^B^5WqUE-}Sh<&fB_MI@8-BB=rUQXgchAiQ zke*OD$&}29)|r=OclL-04adNV@qCoUp5AXKM&#kM3nG4VcT+X4901*BPn4g~md)@- zuH&9_KfeSvN9UXyo96ry#AW{Cojkqv^XpZ_FRgMhzOyI{mm@fgQeB$30*#$)omx$m zWkX7GQyIt97qP4q>}IO{G+g*2ADc;tsSn9AidfcRlKx_Q9BFBoxJta$yG4T z-}(5R$@TW}mS$#yh2hgxqkIfWiYpDbhBPhotSzcowW>hN2^~@Y&|t4*O83oiyqK64 zHw+P?kkfA8n7OuV`nbgwH`4oN)ggVA->jGdfP%hcT9Vd%3*;*-nxgWPXx|E52$tGNDqfT=9 zmo$=nefR|n7b*`rl8JTRmSFMgqROSjjHE$m)c%oeK)IQWkgrdzLJFt>c*7%$>RaE7Uiwl zIjm)PHBvWJUOdA!3j$9W62IiqtbkkD%c>envw?82fMMo;zP~w>ayCc&buNhjEKFj6 zPOH09x0umCpH2W{*S|BPRdi0KRdKOzMvnNsnx6&Anf8a@{o?XSmAa`^(@8}6SCpk# z3gO6qmJ24G(t@&Txc+Z_B0%O)Tc!)qf36VN9y>+4Jl|~~6ZrFXB(kPHCQI(GPhIX2 z>l%qk_=3vlDf-(^9#Wyd{Tt;IoJmw!#*vt6e4K(kgh>bugi-p>gCfe^FrzUEIS)z| zAVKx>FQ@U3hep$kLxjzEDldK2X zgRv6w{@8?{q3Hc@KSdEM!}tHW?JNIjmfG=ELK*FH3fFqfr+364B=yc6%W!b06BEDt z@VunP>kaa8EBh%VjKW?d)vKv@CkV_L^>SitD3-a~;Qux(<}u zt&l+GwurIyEiONQm+)C~AaqsqlQ#$JBjJ(6W@*U@H`}a(b&IvQ*I;*#`l;$nFSdeD zV{l}oYkE3ugj!r6D`e zUkVs>b>(H|JIFVFsO?UbY0DV2HRDIH8qifKX`}S_3T?`Xqe5H;rbV5%N7A0+;h7#_ zM=)tAt-mI}RN%Cq$UWpRji9h-CuiPzTY+kr#4<8few)een3}3pV)S!arAY#5Rmgh| zi#k(z3fF+}y~<-(6=of#7$g)KL7>IiZfT#hVdBc zMIxalzxKH_F|9FmdBw24r2~teLU1`l|1iCk!FbW>3TbsIB^9U52)Dg?92ge*9NJuj z^0{M+gTKtr80-U-L1Z9ENEGQm`}MWw=V#wA@B6zn86$Gc9ZdYb$Zab-J2Y1otDRNS z#K)(E1U=oFVqQ5z5U{w#GdxBTZrKUqY6uf$z!!R+<-cA!T=fBoZLIWD727m!G+B6| zv+(92%3v;o23x7?vq-)X=pUE)dL@7P6n}-kR`8P*(l4QSGd+-bi_CrbveOsooxXm_ z8}2=h7E19bJc%{_)%JTPPu|%XxAQ${L_^Q>a_YX`UYlI7aP(o`SQ%XN6T=pG&UJ(z*w&h^dl+xq&%gXzy7T^y^0t7?9m!`6NW zoX3b_Y9ovO4H_Xyt9KeIWyR}$x&ybPwJxunz%MJPjm=Xak{1^qbuz^#kY!Y^@mEBFy6=#j9G#r}?v6gaQ?-USE)N5DCEx1=+#BSMX?(d)0?zH$@XiV; zh66%m)~Esk@fgm$OnR^(Q$E##|K*XR*M*!{PMq& z`GKI|hW)rC5*_{7BD=xhml-}pIPR_pX`$oa>iX_(i9x}M0H-#BM+_&G!|WtmG(%8e z{^H&Wj|+5DSa{#?$qM_Vt5g~B5oA{u6es>y5TL-u!z0%-tgyYw%sLXV;5nzu+YGEi$AR|T z;Ll7-m0UyD!G%i<{iA|xRD@X1K3)6qtTYa!L~=(O)kKote`<9%a7g`G{`oyq4{JD@ zYFOzR{K<)RmD9#!)z$6k{w_pc_t4$BrekqD8hUS#OaCiIu^Z;Bb+b4bZ5-=V?~H$` ze%GSzuHUY}&cRVv&E8P+5svdI1wtM9|YzU4|0jN>qAo(#srEt&y8 zbMZ+qHvQy(hU9^uM@3oiNd2@-5Y6h;EIeB_oHQG~4Igjnmli84>ND2yMsj0vElQhAkRARcj zN*DZW>z5wY^RN#ei+%oF^YrynlJm~YT9Sb&GP8Zi>Zv(xFHVThxkGgo6KjmJ!Mf3PCDqTia89)G_MNphjfH5YUmP%f5I8t|2d zdyJZDW2AOe(E&4S9du;IzJZgOrA%kwR19(E^Y(6=6=2u+c8QY#!}Mo!WlW6s>WNWv zqbK!jC57AsH?3t5_uiIH;0ca&!0@GHc3Bb$ zg!}2oFlHfDGT!0GIT81=WlC(>-l1fw*#-8l<%3FmlT$yZ&DEU~ju%f5sWyqw4RJ(* zXaNzY{bGkNwS#_c(9`cGpI7$sH)-YRPzlCMd~Q?M_R@vCc?l@Z-r=2Q3JX6@4Q)M&AxI>wO#G@ANnCR4QapaaTyOGxyq*CmUVjzLn=c^+A1K3|a zYMsvkE%r)*8^P_y)b%IXQ+i7Wy$KQzwm9$LTZt6~iTcdkDpo2ZF7mVsJ6x34 z7qsb1gI^nwI~P#GhyN#jp`dUadH1|$qCc*R_Ugw(gl#9}kc#2-^^tga_?|N1vQO*% zV@-7Q_c=VBzQf34^xJRO42wGd%0}4@p-bo=lu=b)j&+MJy%O4@vT~MJF|gIkeL8_r zT!ig|Rzon9Xe|w=vq>oWzOdG)MJ5a}F+MdmM?|#`dFC)melJwSI9FghF=b=0;mCf+ zy>^Z1^LiM*`3#(q^Hll7C!$j0Uf&B%sj5$LBE2mvT0m%uB>hg$X3uz^LvOf~C->J< zD(nPeqgN?UQW}6ffs&FbyGSAZVCf}-m~b}O@UY=Hxs-MJ7QYo1&Mm(f!psyP>{W)s zjjP~u?&Ei}l@r>E*ob$LJgWScq54f?1E+CSOj|dNhNU#)$EiJIJul77=lu*0V&FBA z`4x3nR6g6^WoIU6Ep`IJ&Kd)OHJ2GjED0FR_>QFObQB@)?8dTfo_g=dyi{M35@sz3 z$^i;OOeib z-KMKTmPj-{cka)e<(r~)#4;UX`Bb;3$3TDieymZZAwhtjYEC4)3lzFKnU~Tb*bT7~ zprrH6<*3p7`t~*S=1Ue(N%S~p>EI_0r+{9G@WrD{4`XY*pT|pUq-v#sp2!Y>uEl{Q5*5hVc2PZdma!DGU7Uh)Ydk% z*Ew!)@c8(@i{tlBO*xKdkM=Tfkh6Y=%|Uddo9D1^5Q$FzdZM=ie{gO<#Z?j=-~OPn zemVEnPI~;632s^!C>GqXlohlBmu~x@iucNSe@&y{`Nt>wi%HCBGmQ>5D>xz#g_Bxm zjOg?IHp87UVME{3tr=jqKpkJaNYVOe%Hes&P{P-h+foyY2tmQ~LgVuH02_J@UToFc zOn-lQ&_hCsTL)pUR|t_1Y;xQjO5ojy8>wcEjmYUWd8Ux8Ryd2Uj>nj~(a?O`T6O5@ zud(^JRkVRN+ZTydG=ZYar*|Ecfv}AZlxtlokUOPJf#hiK?qljLIhmAmS{1WKdv0z# z@9X;2dmc1ksB+H8rGGY(6y$iW8OL^&4iX?(WU)odXCBp@201KNn&wKcS=}@;$249R2j;J z^yPqZA>P>kaDYK~ZY`H;tVfMTnx$?g=dF_U{$H{cOTqF_hw?M0 zjl7Dev|XIcHVw1=B_2pfx&i|8GCIHCre1Se%$JzkA`Z`90K@RCM#-5aD@Lsb)8A|? z#BPqW2xRF~Q+N_e49qL<){QYFYK@L`x|Oz8^Y{N}5rgiD#^I$HFH1_LRpMl05X~zZ zLlYCFFX7?e2jECb2yNNzK7j=f`rrf=v@RIC0z|_^vZb|hpeN; z@Z)i6m^pQ~JdpE-H6-(+{wlu=ga)7XPd_*K+L7QkJ+~e578xliBT;6=J|3wn{Z*ZG z$wCQ5=ie)H9rq4DFZ+qP+<3O-RB5x%?Gq#X(f-d(iS|ag@e`1V-;0x7qyxhv2O_XM z>rqgL8c!sS6LBW*y5<1xtoMjx(~o?HpBraCz2c0@84S$pheH`7(og>9gaV9gH?%Ds zOfy^u9~NDL{?y^iLs&-&d&uW%ZVBj%!dG`TQr(#i&Gv6ERvT9PPHAUtm!g8PNZjo$ zdP@r!n)%s;?zG(8@Y%ZCaPb>bc0OBBQD07*$Rz(X{Up12q>#?*$J^n?ivA2`&Er^_ zvKgMd4m1CTM#cvBv9YM4;aYytV=5Pk|706DPn@{=)pR+wYnAGaFrf_dzkq7oQB0mz z1$QOaW6Q|Nd?BSPpK)pCk{Ta^x)5X#!P4oVs`5@mY(o1Dd{&=Bm7|fm0$6K!{)+X`9}~* z@FbDfq*x4lJVl*$aZIlGkymoJ48ybMSS8f|$q^{&ImI^NyW^kyP6QLqOs8B=@C?3B zgk9=!&?746)|^X4pXoH%!Uu5^6Qe*3!^vGoq+Q(zs%xz_SW2O0@$>aB9+4d_UGNz= zKtfRRB?u5YJ3%-8w|H7GY54RfWMk$YCm1ikP*Ep9lKh_{qBsruoqUCFvx=8EApMcR zVTQpS@hFXe?8qX&%VR{3IuK|FiF{khEg!^CPzz_AXEkl=wUJ>iJF1mFUvHC>q-9l{ z+}6gmpGXqCN#wO77DGdMRjsNU>;vQSG&okp`2&@j^ncYmK-#{VF0fThzOQj(*ebHmKMyz(v z4bF<^soXA}H@uV$OiGTaV_Uc^dfL3(=@`|yRtKsmqH#gRiS~0$8Zr~-w3lqbvGJJ? zQ`ui@Nu)T<+PMYh7ALOe&lnm+(CqxHq4cHb@GgyHa9l?BfUNR!iLJ295?VVl;TGa7 zF@oJ1KJ!JnCBkIAnT~9sc&y@8>mij?Om3My57sl%d6Kv>_uPJWY^Mgap58(V_<~()uHA1`fbB# zA(Uh3l>lZm_xE-c50s;@`lHE1tFt$VgT{qBUHm`7P9v620y5yCxt>pgA}62y5v4#R zi|6UnLyVw1=yDW2(ncx!0ss!Eff7Xg{qGV4i3%t|kYZ+LH=sB?W@g?M5W9z(epHUG zN8PAaq2KoS)k9nU?JH2^5PQME#@sdN3qR(kHUeAprp7g&YH%33K!;Q8C%A$ILw`?5 zR%{(N_8A%INBvu(*UsjiKn$ za9$bWr+`#gIiA-+%{llFGem`8wbAchS(4dEGT=>;s5BE&PolMrL(*@|Vq}uHuz4(n z{_9GRD3#52c|PT_ITMUOn*`X~I|u7}Vz2TmWS1erbz=f-VH}t2&YgSC2Gd580y6}0 z5)xE?@MFC#OfJLXKhHec+ijtEjluF8uBAXl2M`D;Rjb&w);ZaPCO|Rl0j;o!>6vjY zcy~?pFb+HjX+h{%)28zoGp}oL{Y3~!ROB(A^-lN;>m4qL>tZ1Wb%EkVj`$6i$w-Px z`@e3P#q}wP*Zlg=uv#}~WTb4N^;DRMfuN`^7TS2+9}ZjA_vN2kl<%5ai`Mb~HOe-E za`#YO&cjD8gJ!@ubAUXj_xTam?~i;0CTELfvT?cp{`>D|@WAAnC9U&T&ZF-XA0}t` zFgaZs=PXBRfy{?D_rQQRH}F0+9sG2f^UpJ%ez~XJ-x*T>GpvJy_)It}{_pu~KZpg7 zhYFqcjZ)#mR4RW@g^Yxs^s7DZKhGTAZ0*XV+5R)EWZyQA=%+MON0K&ZAUn(l*-0nA zXqi4I|2?qC!@wl}mNy*uq|txN`}Z^b|B^TK!zVfYTi$maq^?qe#4SaUfJx*C^vMJTD;%31 zk5P^0$&-lDB;2b!+Gu5ix$XJr2f4!re5f;CY;`9iBP)PZx{Y{RR!)Y&dzM-bUBVY(uBclJuE#*bKmU z;N@PKnP~xhiREQ8Aftn4BuU>AiORR%p6SNX5eRwlPR4(|;b=$Q;*&YWPt_IVm!FA#l2KB< zPkFIT_Z}f1$M_fE+U$4Abn1T8(Xg={fJtRPSCOc*{H9rPcd(vLlqAzs&}m`}N9bwX z>Mm~wz^f3L=T?J&YrV)~OP*;wyroZ*s9QVw`FWgn31F?O{V%3qa%zpgeRxg-=o0Z6 ztbiwn_5g}BLRbhGy&H_De~=%?r&>4`NMmqSLc+a*C=i@pqdoKv2AKfG*~P^hefgk+ z!^2-wyFEW5#F%3p<$ct`E?SS@rPZ1Njbc-Imw0h?MdS_VZu%(ae%iqICx^(r$7uSw zQ=~*4+?SP=6`Q$QMnDF(v|N|JY>|PNlfS@cV>M_GBBj(Of971Qk|Tx=lbn_Y7Db*9 zhpSqrJ6hiO=GY~E2=)i`MAmsqVq%{a63#-kiM%e_@bGXpJ598TeEz)8Nz$Y1EmWV2 zjTduoMJP}oSx!LkFs}dtIdTukcuefP+}yCITwL#`Apw9JwVA2xnwhx(BxefWcpN~~ z#5!p)+9gDPzmnak7xAcFqEFa>r$j()6*BOm)?76P`=}EcUU&KJn#FiFbOo)Ntt8fx zVRuXGuK{>_k?1=!oqgd6pO3AE__8c{SKe??s6jwC?*cD zDjJ%g1llcO4lA%IoVN4H-Ug1BM?V3Jztrde%Rb-XORkYP4Y7wgN0$BEXcEh5tUot} z(eniATxqQi8OC3Q1Cu(+~Q_%AN5qoi)yW z-5+I4hL89dM^s7-oGJLI-{t{;L6B>(JFP3|%cGME?QCvp*IUol+k78tG&!7}tTRir z-SE}Ncz1oz4GxcZ6>G_3;w;YvhD=Nei11!uvgEoX174+rOEj2I|+?WTIW%$qb?5cX7fRpd1yU$(f$`bO5) z*OT$PmLA;tE*>78-Bvo<3|Pf|f7<_JF3R`(=I3InfkewmQ4Mfb!LSb@4MYvdtI30z z%10Pc8ByheP>=%-lN-lppGnjPK*UElmN*s*!K2_%O#;S4gKQP=>X-rW=(`xH zoRjuc?2$@HV*1NEDnS;gaEUFBv8z(RYcVI}(AuXt&S!!CO_uwH2$W^GC77ZFRh@V) z?SxPo@S4C&QzpyWBy#Z`b+WsPK z*6eDF-AO)XQl==L%~FH$=X%4sHgqqppIbh@EY!gZkHROh!V@n>wRiUS$;rsjC*Y*$ z**J4_xgL_7+*fy`?X=&Mt%%!w!6Lo1H>{%J-TdU7AmHE47%`65cZW zsL^h%_gpNFNc3|EjyiQf8kz!;a3sJXEo1-O(EUcpQrFKWbe#Hy6pc`qRa)&i8?&9x zaAR_CoymEQpamZvgv4n2&~+GnDrd^#58ODFc|VzzS{(Feh}`5@$ku#@hcvrgja$`^ zJ}DT#+;N>;cem>A-k^-S8 z$+gy&6%*c{Q{S7^!4c@!czSqIfFloK(-iP_i|KC;D13Higv!ggW&|Edw%ck|?4coQ zBddXfD*W8U%9C+kbe7?%VEJhJA~T2tY(J=w6M zpsStC{DM746n4Y%n{^2KErpJWQyy^FhR!(Jh?QF8zbV8_SV+M+u+q;W8#}XC}JgOefs#k>r9S~{nF^L`wzb8O!e3j zZ9B9Mak~#&!xA*KbA>Kb!)(2;xe3o+w%_o}0EpsO&DdMe(|g@-6oXu8H_!WhzV+sK zL%OMS6`~s2tploqztuC2zj%*)NZC^tD)X~-L+ylqmA|n?%O}_n?ps1eyMjTDVBP#btZD#?v--pJo&b2Gm)BgyOkW;xe^GF}&Z-6p`^st7LRRjr@C*k{VLZ}pCEf>H-@8lC zmG0o2CyZJ7K+U4baLJR>`5S7iXTRL+aE&7o5Q}#A^#x3WcgvvHNh~~QRNlNtcsr|q z%vKUX=UaqN869>JB}<_|EW%n_vo+Kpt)xbk9uUu5AKA8@VIzj%vq*Hm3N{~H@k@pyN= zKl=2D{_JdO=Q<9X-qq{Q{S!WG90e&>711d3M4ZQIdRXBQPN)R4Du;@ELhtI5Qc`L^ zm-7+gA_G@6lj~6FB+2k96*@qe0X;NZZ9-NhZZ|6r6 zXlHv1XI+7BSooP&IODV7(RWaF4dKR%Rm(OvT}sKPs7i@va_By4Dq@YI<#{1nQ8nXo zR)Y@W@&{m^;-RkBE1|66OykVb{X?Yu+$lodZ_0GOg(U_Bl~&f*`z`R;da)MgqW|S@ zA4?^zjj@~_z{20s^_5`L}F3wA7xfpTj)892L_pB%JZNX3p7 zSr7h?qpkiv^6swVToL6RAwD&!E6l{bXY|VsOM?ad*}J6{k2jm+iTrM7W}S=+x9R}p zjkV|>XvO^F8VCSjhgdcrt`lu#GM?JED=?J6tX`|FI&s=a6)y%@#~*faX$bo;ZmLsBI6 zrLaHtn@-61>(IX>-n5T%lh|SbdKC92m{WUE`To-j-2pF}-=FY1MVN$efg~zi!ZP%? zNC84OiT?0b6Z65Q=S<7ol2ox*!+_ia=^2WN`2($o3@#%*T>kd?>naQ=^#~o$fB0EU z`yrUUmWFf*Kq($${1@#KpTM4(Dt31|1NIKM*7S_s-Q6-9 z8)gKwtzpvvT;ZIf*)PMxlYMT(+Nan=iNe-b?wo+3h>Dc{besD*AQ2 z5uL&709Ccrg0I!y`U_wMyrMq=w&3FCR`Rl?`J+`N;LO#8g5fZ7U!x0I3cJTai8JuR z#`s(uP2cRr8 z78Ps)msKGe`JU`f{t*Di04ulmP#QOFgguQtVl@7T%PW3a@b*0btpS^UePSUUk=sx3 zfCQfYMgnsZF_D^_8Id1%%91cXAO{hNVfsX>)JdV+pYTH`9~2R_&Ro`fa|oT32pc5` z9HcTDXTs-lOwCrW$o$IMF-((Y4AzY;?(D?6%a?;BU;!BOGgoUEXp}X$ooqN}ok{9a z{e?v5V#9OadqtWSsGK}S0gJkCx-0yWx8%{6*NLSK(pB5JE*4KRGbhXX`;F)oHF9=gU^Xk>c;ed00H}w{vWkGdRIBlG{Qfl$7 zdaU{N4+dH+DK93bDPm8LCxjYK#HTo(!fqlnT|OdXMh>HLc|>l6E#YfuO+}4C;ruqI zh4~3SqPH&tOu|Dmev+=bl95TZWCDZ>RqRMDaGu#kvMKP$&)kA6^$$z0mC!vWuWV)(?< zZ8I**lY29|gxG5W+Kpktg?bxm$S;t^+0M@(gac}*d#2WURze1ZNbH;ZqI-v5Y8uu% z@JE(J&1;2)bc2I;YlpXsZQBF-pnDcna1a#GIXIrPfcNAgl_zc}5W(sAXpIoxxt5Yb z?h=Qc((rRIN^EIH^c-8<=4{P3o~09Tq=mpxTm0D(W}e}1obUzcgFQ_9e_wkfn%vwe zz~9+Be)#g?+r7c}w?vl=P3999g^CMg!b*s!dO84p^|^ia#xpw4D88iyB|>a&WO$YQAWa*{zio_yUaz+s_@j*|l)Ij>gd-2aTVR8_>EN&tXO*o`S(( zVfi-D;-;D`32;Gxhgw@d0XcfV+qc=*5mEYDEv_yM6SK3KTD*kJE4`MV02i9C z2{2Vn&GjJr(f`XLpUhe}Q!~NKc+=^#zQhJ$Nu@FohxaKrA$zy%y|0sFr%#5sEz1W0TN?k`_MaQ|0_|IeV{ycdlc|AT6v z8psb1E7({++1V|7U`GfhUY^v{v9Be4`oh zPtkPXL@J-CK){x*etX3==r-yfig7>H>JBQ0q{P3Osk~xrkoMrN48#hCpdI75Fq8ra z1K2}U)cYJwAt7}U<}iol&e78?KG7UOk6J1N29WmflECaN=1R7KBUx{o13cgnSm}TD zM`J(Me1ZUr(;g?2FYq9fM^@oIsnFD7MQ_Lt==AJgfdh{-)|ho4HL4u#i}e7hbw9$O z$_$R|jPzegN2A9EsmO-~={4h+0R0UISd*UK2e5fYdGNylhd)2lJkSsX%>Fq@z0Rtk zUI5HmY$becXb3Od)#&)sSYICe0ud3&JG{uOr?25;kHPjsD~22J*t>I{T0t?=cPqpY z#)td>ghR%r%FpRDm#v9Uq72kr9o)Ey$?I}Bz;EYJM{GjM-xrEaiJcZU_@ zi|SrLIlArXJrZ==T*ua|u=Tw2f&(^;XeHTb*yG8J^&8-}k{LiIaL1&l&}dD(Ir=uo@IK8-->cywG9$$+II_)T*;~cwn7?=s4 z=JKlyQI>#31Sg3EJ-_I{1cnoF?F{5GGc+ish0wrO(B_u2v#Y(uWx86Eg|YJ&xat2M zI{*&&<(e{R%TLjiKh^yb*vjhPp~-YL(820Y#uKz)*Zxa-2b}NXvE5na+$Ro8)axKa z6D5ZLe7#HaXu*Y$xe0VDc{lQGjDB#d0;24*4iiB_a&m%zJG;yu_=?A_FBw3WV~v`n z$r80R;DAvCw@m&2;q5I0s_MG-UqL`Zq+7a?66x;RNQt1E?vn174v|#4LqNJ4q(PDH zmJ+0-8_wM5{oK#{p7THF+xZG>ueD~ZF~^wWH?DbeEpPyZKaflF3T=S@gJ$}g9z1>+ z+K=*Q2BFwq?>mi89SD!RwW{J0(XPx{^*Qly2G%_?CuC);u(R_e}#9FM|Y63!! zrsf_j7GF#)V66z^Ex>jJU~ZmQ^qHa1MBLfIb%5}|&}fbzuzsCEr)Qw;x@@HreSPFi zgZ#J?VvdEax7dV%oaW07uKPSjWyfHbLRPjX;`!3vYM(!dYDNHz-S`)aE<8W%fx%BX znet1qInli-F!x&-WEy?11QLoh34WJK3%>_W!rPH34Z3XUe$=m#5yQ7I+Hupb2{eI-v`T?)0r8eC5)%3^ zg>a57#q}CVt%QmU*uxk!Ayflr^*0<a8nWHXbSZ-{vM zbgNGZ1EUs%X7+`&2V07$1QugdYiQr&;@S2%xVZRStm*SmE&$OIqU|^@XK)^XZKwYg z9@cK~>78GX#i5Fv(A*aC>QBBANN1B=Ly%8@X3BZwL#cE4#P2t>y~OuyC2|o=@pz*~ zFM)}Qhd%^Rhgygq{V9_Jg*0${IvZA}RPwJJuX(h$Zpv`z( zCNM==ChjeZ!!liMS)82g{|-_;QA`rWrM5muE?~EOZ~1DWx$a=?d7q%(4MT-?J{D6M z7;R-*LiERiXXGK3Ku_g<8Xt}{hgqRAC8bDXyAPPwfM)~d4)y(5Lu}N^3E2a2+4UHd z+pb`3ofnSg5YU05cOCc&^0|1IO-sVqWE*~%OD)3@ba)CK1qk@(>MPT60_dI5C8H2v zfMxoxc2`ty3aHp}d!Q^P;d1c2kkB{{e>LZ(4xWh^9nq`u={r#5)9Y^%ubBS6%IcFat4uR7{j)3dtQ*s z!Ux($@waXH)uhcU_@N~`vdg@39_}?$^$vJ2TEmhef@}xG6c3TD0B%OpjxBP<)EX6g zrtcC=32AiRZAXpr(m#VwbVD=iTl>}sv=!jX8^MPd^*D<*GxLdnqid@HVIE2&0P}m{ zU$bjb(6;m5L&B%I&li@$Jcev;-vl7f@4~DWiBV;U-4;

    X|h62V?2|OLQYYg$LNG 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 Y%N4F4Gn;|10UDZ&q=G~`Qpfdw0UUnbEC2ui literal 0 HcmV?d00001 diff --git a/etc/business-delegate.urm.puml b/etc/business-delegate.urm.puml new file mode 100644 index 000000000000..407e3e12d1ea --- /dev/null +++ b/etc/business-delegate.urm.puml @@ -0,0 +1,46 @@ +@startuml +package com.iluwatar.business.delegate { + class App { + + App() + + main(args : String[]) {static} + } + class BusinessDelegate { + - lookupService : BusinessLookup + + BusinessDelegate() + + playbackMovie(movie : String) + + setLookupService(lookupService : BusinessLookup) + } + class BusinessLookup { + - netflixService : NetflixService + - youTubeService : YouTubeService + + BusinessLookup() + + getBusinessService(movie : String) : VideoStreamingService + + setNetflixService(netflixService : NetflixService) + + setYouTubeService(youTubeService : YouTubeService) + } + class MobileClient { + - businessDelegate : BusinessDelegate + + MobileClient(businessDelegate : BusinessDelegate) + + playbackMovie(movie : String) + } + class NetflixService { + - LOGGER : Logger {static} + + NetflixService() + + doProcessing() + } + interface VideoStreamingService { + + doProcessing() {abstract} + } + class YouTubeService { + - LOGGER : Logger {static} + + YouTubeService() + + doProcessing() + } +} +BusinessLookup --> "-netflixService" NetflixService +BusinessLookup --> "-youTubeService" YouTubeService +MobileClient --> "-businessDelegate" BusinessDelegate +BusinessDelegate --> "-lookupService" BusinessLookup +NetflixService ..|> VideoStreamingService +YouTubeService ..|> VideoStreamingService +@enduml \ No newline at end of file diff --git a/etc/bytecode.urm.png b/etc/bytecode.urm.png new file mode 100644 index 0000000000000000000000000000000000000000..51335fa0a4b40a73957b56e79805aa9aed7e4cd1 GIT binary patch literal 86123 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 + - wizards : Wizard[] + + VirtualMachine() + + VirtualMachine(wizard1 : Wizard, wizard2 : Wizard) + + execute(bytecode : int[]) + + getAgility(wizard : int) : int + + getHealth(wizard : int) : int + + getStack() : Stack + + getWisdom(wizard : int) : int + + getWizards() : Wizard[] + - randomInt(min : int, max : int) : int + + setAgility(wizard : int, amount : int) + + setHealth(wizard : int, amount : int) + + setWisdom(wizard : int, amount : int) + } + class Wizard { + - LOGGER : Logger {static} + - agility : int + - health : int + - numberOfPlayedSounds : int + - numberOfSpawnedParticles : int + - wisdom : int + + Wizard(health : int, agility : int, wisdom : int, numberOfPlayedSounds : int, numberOfSpawnedParticles : int) + + getAgility() : int + + getHealth() : int + + getNumberOfPlayedSounds() : int + + getNumberOfSpawnedParticles() : int + + getWisdom() : int + + playSound() + + setAgility(agility : int) + + setHealth(health : int) + + setNumberOfPlayedSounds(numberOfPlayedSounds : int) + + setNumberOfSpawnedParticles(numberOfSpawnedParticles : int) + + setWisdom(wisdom : int) + + spawnParticles() + } +} +package com.iluwatar.bytecode.util { + class InstructionConverterUtil { + + InstructionConverterUtil() + + convertToByteCode(instructions : String) : int[] {static} + - isValidInstruction(instruction : String) : boolean {static} + - isValidInt(value : String) : boolean {static} + } +} +@enduml \ No newline at end of file diff --git a/etc/caching.png b/etc/caching.png new file mode 100644 index 0000000000000000000000000000000000000000..b6ed703ab8b7dfce5e5d82f097dac534828fc93a GIT binary patch literal 114847 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

    $0ITcj(KRIbdLxc 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 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/etc/caching.urm.puml b/etc/caching.urm.puml new file mode 100644 index 000000000000..a9dae801eb20 --- /dev/null +++ b/etc/caching.urm.puml @@ -0,0 +1,119 @@ +@startuml +package com.iluwatar.caching.constants { + class CachingConstants { + + ADD_INFO : String {static} + + USER_ACCOUNT : String {static} + + USER_ID : String {static} + + USER_NAME : String {static} + + CachingConstants() + } +} +package com.iluwatar.caching { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + + useCacheAsideStategy() + + useReadAndWriteThroughStrategy() + + useReadThroughAndWriteAroundStrategy() + + useReadThroughAndWriteBehindStrategy() + } + class AppManager { + - cachingPolicy : CachingPolicy {static} + - AppManager() + + find(userId : String) : UserAccount {static} + - findAside(userId : String) : UserAccount {static} + + initCacheCapacity(capacity : int) {static} + + initCachingPolicy(policy : CachingPolicy) {static} + + initDb(useMongoDb : boolean) {static} + + printCacheContent() : String {static} + + save(userAccount : UserAccount) {static} + - saveAside(userAccount : UserAccount) {static} + } + class CacheStore { + - LOGGER : Logger {static} + - cache : LruCache {static} + - CacheStore() + + clearCache() {static} + + flushCache() {static} + + get(userId : String) : UserAccount {static} + + initCapacity(capacity : int) {static} + + invalidate(userId : String) {static} + + print() : String {static} + + readThrough(userId : String) : UserAccount {static} + + readThroughWithWriteBackPolicy(userId : String) : UserAccount {static} + + set(userId : String, userAccount : UserAccount) {static} + + writeAround(userAccount : UserAccount) {static} + + writeBehind(userAccount : UserAccount) {static} + + writeThrough(userAccount : UserAccount) {static} + } + enum CachingPolicy { + + AROUND {static} + + ASIDE {static} + + BEHIND {static} + + THROUGH {static} + - policy : String + + getPolicy() : String + + valueOf(name : String) : CachingPolicy {static} + + values() : CachingPolicy[] {static} + } + class DbManager { + - db : MongoDatabase {static} + - mongoClient : MongoClient {static} + - useMongoDB : boolean {static} + - virtualDB : Map {static} + - DbManager() + + connect() {static} + + createVirtualDb() {static} + + readFromDb(userId : String) : UserAccount {static} + + updateDb(userAccount : UserAccount) {static} + + upsertDb(userAccount : UserAccount) {static} + + writeToDb(userAccount : UserAccount) {static} + } + class LruCache { + - LOGGER : Logger {static} + ~ cache : Map + ~ capacity : int + ~ end : Node + ~ head : Node + + LruCache(capacity : int) + + clear() + + contains(userId : String) : boolean + + get(userId : String) : UserAccount + + getCacheDataInListForm() : List + + getLruData() : UserAccount + + invalidate(userId : String) + + isFull() : boolean + + remove(node : Node) + + set(userId : String, userAccount : UserAccount) + + setCapacity(newCapacity : int) + + setHead(node : Node) + } + ~class Node { + ~ next : Node + ~ previous : Node + ~ userAccount : UserAccount + ~ userId : String + + Node(this$0 : String, userId : UserAccount) + } + class UserAccount { + - additionalInfo : String + - userId : String + - userName : String + + UserAccount(userId : String, userName : String, additionalInfo : String) + + getAdditionalInfo() : String + + getUserId() : String + + getUserName() : String + + setAdditionalInfo(additionalInfo : String) + + setUserId(userId : String) + + setUserName(userName : String) + + toString() : String + } +} +Node --+ LruCache +LruCache --> "-head" Node +Node --> "-previous" Node +AppManager --> "-cachingPolicy" CachingPolicy +Node --> "-userAccount" UserAccount +CacheStore --> "-cache" LruCache +@enduml \ No newline at end of file diff --git a/etc/callback.png b/etc/callback.png new file mode 100644 index 0000000000000000000000000000000000000000..7b499f79fcaa1484dcdd485668c14549eef79b6e GIT binary patch literal 18256 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 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/etc/callback.urm.puml b/etc/callback.urm.puml new file mode 100644 index 000000000000..2d213eda800c --- /dev/null +++ b/etc/callback.urm.puml @@ -0,0 +1,23 @@ +@startuml +package com.iluwatar.callback { + class App { + - LOGGER : Logger {static} + - App() + + main(args : String[]) {static} + } + interface Callback { + + call() {abstract} + } + class SimpleTask { + - LOGGER : Logger {static} + + SimpleTask() + + execute() + } + abstract class Task { + + Task() + + execute() {abstract} + ~ executeWith(callback : Callback) + } +} +SimpleTask --|> Task +@enduml \ No newline at end of file diff --git a/etc/chain.urm.png b/etc/chain.urm.png new file mode 100644 index 0000000000000000000000000000000000000000..c3a4c80ba322503e86be815d9af389597c212312 GIT binary patch literal 60093 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 L^>bP0l+XkKhV(}E literal 0 HcmV?d00001 diff --git a/etc/chain.urm.puml b/etc/chain.urm.puml new file mode 100644 index 000000000000..43c78a04223e --- /dev/null +++ b/etc/chain.urm.puml @@ -0,0 +1,61 @@ +@startuml +package com.iluwatar.chain { + class App { + + App() + + main(args : String[]) {static} + } + class OrcCommander { + + OrcCommander(handler : RequestHandler) + + handleRequest(req : Request) + + toString() : String + } + class OrcKing { + - chain : RequestHandler + + OrcKing() + - buildChain() + + makeRequest(req : Request) + } + class OrcOfficer { + + OrcOfficer(handler : RequestHandler) + + handleRequest(req : Request) + + toString() : String + } + class OrcSoldier { + + OrcSoldier(handler : RequestHandler) + + handleRequest(req : Request) + + toString() : String + } + class Request { + - handled : boolean + - requestDescription : String + - requestType : RequestType + + Request(requestType : RequestType, requestDescription : String) + + getRequestDescription() : String + + getRequestType() : RequestType + + isHandled() : boolean + + markHandled() + + toString() : String + } + abstract class RequestHandler { + - LOGGER : Logger {static} + - next : RequestHandler + + RequestHandler(next : RequestHandler) + + handleRequest(req : Request) + # printHandling(req : Request) + + toString() : String {abstract} + } + enum RequestType { + + COLLECT_TAX {static} + + DEFEND_CASTLE {static} + + TORTURE_PRISONER {static} + + valueOf(name : String) : RequestType {static} + + values() : RequestType[] {static} + } +} +OrcKing --> "-chain" RequestHandler +RequestHandler --> "-next" RequestHandler +Request --> "-requestType" RequestType +OrcCommander --|> RequestHandler +OrcOfficer --|> RequestHandler +OrcSoldier --|> RequestHandler +@enduml \ No newline at end of file diff --git a/etc/circuit-breaker.urm.png b/etc/circuit-breaker.urm.png new file mode 100644 index 0000000000000000000000000000000000000000..fc90318ec8daa0b4115eafd65cfc710110a374bb GIT binary patch literal 80659 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�O{metRa5&hF57@JH5W;I@>O(!52~ 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 QK_E*!UHx3vIVCg!0CxMjSO5S3 literal 0 HcmV?d00001 diff --git a/etc/circuit-breaker.urm.puml b/etc/circuit-breaker.urm.puml new file mode 100644 index 000000000000..951ec02d31c5 --- /dev/null +++ b/etc/circuit-breaker.urm.puml @@ -0,0 +1,69 @@ +@startuml +package com.iluwatar.circuitbreaker { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + interface CircuitBreaker { + + attemptRequest() : String {abstract} + + getState() : String {abstract} + + recordFailure(String) {abstract} + + recordSuccess() {abstract} + + setState(State) {abstract} + } + class DefaultCircuitBreaker { + ~ failureCount : int + - failureThreshold : int + - futureTime : long + - lastFailureResponse : String + ~ lastFailureTime : long + - retryTimePeriod : long + - service : RemoteService + - state : State + - timeout : long + ~ DefaultCircuitBreaker(serviceToCall : RemoteService, timeout : long, failureThreshold : int, retryTimePeriod : long) + + attemptRequest() : String + # evaluateState() + + getState() : String + + recordFailure(response : String) + + recordSuccess() + + setState(state : State) + } + class DelayedRemoteService { + - delay : int + - serverStartTime : long + + DelayedRemoteService() + + DelayedRemoteService(serverStartTime : long, delay : int) + + call() : String + } + class MonitoringService { + - delayedService : CircuitBreaker + - quickService : CircuitBreaker + + MonitoringService(delayedService : CircuitBreaker, quickService : CircuitBreaker) + + delayedServiceResponse() : String + + localResourceResponse() : String + + quickServiceResponse() : String + } + class QuickRemoteService { + + QuickRemoteService() + + call() : String + } + interface RemoteService { + + call() : String {abstract} + } + enum State { + + CLOSED {static} + + HALF_OPEN {static} + + OPEN {static} + + valueOf(name : String) : State {static} + + values() : State[] {static} + } +} +DefaultCircuitBreaker --> "-state" State +MonitoringService --> "-delayedService" CircuitBreaker +DefaultCircuitBreaker --> "-service" RemoteService +DefaultCircuitBreaker ..|> CircuitBreaker +DelayedRemoteService ..|> RemoteService +QuickRemoteService ..|> RemoteService +@enduml \ No newline at end of file diff --git a/etc/class_diagram.png b/etc/class_diagram.png new file mode 100644 index 0000000000000000000000000000000000000000..10d509801f79b7c9172c87731233d6753d597efd GIT binary patch literal 32958 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 literal 0 HcmV?d00001 diff --git a/etc/classes.png b/etc/classes.png new file mode 100644 index 0000000000000000000000000000000000000000..295719ea37125d8b49bb8967e2269355d6901c6b GIT binary patch literal 45639 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 z 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 E2VMR^U;qFB literal 0 HcmV?d00001 diff --git a/etc/classes.ucls b/etc/classes.ucls new file mode 100644 index 000000000000..4a869b9d24e2 --- /dev/null +++ b/etc/classes.ucls @@ -0,0 +1,124 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/etc/collection-pipeline.png b/etc/collection-pipeline.png new file mode 100644 index 0000000000000000000000000000000000000000..67d52629cb86fc32c1520a7ebc8d5b685361fb69 GIT binary patch literal 27282 zcmc$`bySq!{x6ONC?X;fG6EtX(vpKxN_TfRGQ>zXsDu(jm!x!ex75%eEj2Vq=g@JV z!E?@s&pGGb^+FLYQ0RrOiVTp&y6crUCD+1DN|D;1Bxi9H zWc;;~(`pwqq8DjQf&~ivK=ibzt;UUUO-EVTcqDN%f3q|D%ykaLI(%$+eyL>aMpsfS zdU`_ZuV`=3q4)p%S|8>z53)RJ#jW(>q|oxd(+KF5lzQ`SBO0;SZM4cD zb@@ev>Y1L$C9$>0&XX1N&o{`2WWyCj{dC{PVBYl#K9!fCtu3la7Ji3W#UxHkDfH@@ zl-F(kcDGsBDLLdZ@IrDbzx?f61A?N@ye0_|m1O_JSEFJPj!@nweS{YDkRsL&AClPa zLqTz(fX{`e^Yy(><1AVjw;*zwYVS*SD^us@o)dk=;J<0{PE+%J32`a-K}JeHTX)nG zZ+Dsb1mZho2Qz6D#o}cUg1d#2;(giDH(?o5 zqjVCK#9)05O%Mqoo%65zKt7L%rmGeWH4*8gy+^YWk&@daIR*zL7YzrUgWkPg^l6z3zjc7%7^Ab4qE9o zeMM(bDTuYjT3dx)J;d?4J^s0}GMHjK2CTjMNu0cXaGAwQ8rN{g z>+1@4Zz=Z@zhc&>e1_L2A-pEl#!_;Mr>bV2%cfnjDU}TQ^b5g0N`F&yA-H@AMlsAS z+fgI1(C4+#wPPwt?X=tbsGR#-z{Ml3uzt4ogu80X;*98aj11lw+wJeHjL1dUYD4|} z{dJ#_V%{yiV`W7yQmO=v%Ub{Bw>}%py-QOo_bi3=K0M4fZYqIVX~pG0$;K!szWcHE zB!8ek9hP10Y^0*5=IvWMZ$-Z|eDw$ZAYE%!Rje|BLZ

    nH)93|` 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 QKcl!QuX+tDcklVX0RJtv + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/etc/collection-pipeline.urm.puml b/etc/collection-pipeline.urm.puml new file mode 100644 index 000000000000..8cd51c44656b --- /dev/null +++ b/etc/collection-pipeline.urm.puml @@ -0,0 +1,52 @@ +@startuml +package com.iluwatar.collectionpipeline { + class App { + - LOGGER : Logger {static} + + App() + + main(args : String[]) {static} + } + class Car { + - category : Category + - make : String + - model : String + - year : int + + Car(make : String, model : String, yearOfMake : int, category : Category) + + equals(obj : Object) : boolean + + getCategory() : Category + + getMake() : String + + getModel() : String + + getYear() : int + + hashCode() : int + } + class CarFactory { + - CarFactory() + + createCars() : List {static} + } + enum Category { + + CONVERTIBLE {static} + + JEEP {static} + + SEDAN {static} + + valueOf(name : String) : Category {static} + + values() : Category[] {static} + } + class FunctionalProgramming { + - FunctionalProgramming() + + getGroupingOfCarsByCategory(cars : List) : Map> {static} + + getModelsAfter2000(cars : List) : List {static} + + getSedanCarsOwnedSortedByDate(persons : List) : List {static} + } + class ImperativeProgramming { + - ImperativeProgramming() + + getGroupingOfCarsByCategory(cars : List) : Map> {static} + + getModelsAfter2000(cars : List) : List {static} + + getSedanCarsOwnedSortedByDate(persons : List) : List {static} + } + class Person { + - cars : List + + Person(cars : List) + + getCars() : List + } +} +Person --> "-cars" Car +Car --> "-category" Category +@enduml \ No newline at end of file diff --git a/etc/combinator.urm.png b/etc/combinator.urm.png new file mode 100644 index 0000000000000000000000000000000000000000..80fdd36340bbacbbfd19ed0a4aa70c259b53c397 GIT binary patch literal 22657 zcmd?Rby(GF*9M3MQlcOrtpd^@Ev+Km-5}lFEg(`-(k;2^O$mZ*K)O@dAl50e?H(y$L>n zp2EL?f6zDxsXFLe+qha78aW_|7+M+H={gu1Jl1o4Y~tWx!_CBGW1(y1;Am;VsBdlg z;5ipD64K3kri!W#e?LdM0UqO$9HXdVJ@ovcS5?K84Jk>?8!46k!25(2TG^kN1pZ45BKKR;-_k-C?8_) z;-lxq4Oc@xpZScqJRBFi*K~0f)(FM6GoD}zW(a$%d%|| z@u}XbABU^EeA^lMXUfJ3{p`USte#zR-ZFp354P~K7^jDAI+Oh$%FH*`k};!pthmv-ht$X^-Ee_avBBy zwkz?QuOrbz)s6frKb|AQCrnk;mC$^Ukd#iu-n>$D(cVZw@pve7b#+VpE^7Lt=li!; zVSe(_PiaYBy$rtT`}nEUs~dTQ+_xj{1^+-26Meid>-+e|(+3C3w|wt(`LV@3!xB}y z(y@Ab)z#ZOrG4mRU**9MJwj-^+n1Nye`8HcnM^s;Zm7S1`&Gmc?q}(DkMH^tQ@QYg z|J=I+4S0Olu5RW4{LfzeT2kM~?I*r)!TYzlbhh2@`aWJp*T#Bvf5GEB;>lg#WTyYe zFA2jg=UPH&?i(anP1WXE+26nIDkBU_b<;<>t(H@yQI$VVeEZc@l(Dve`A8v(i2nVB zJBz(3X9sW{l`5{gzO__+wW->}WG^F39XBVqczMrzQ+U>}9^c*lG;<)kM90Aqs}BE> zryy{)UY;oup33dGw!7H1CVBsMLWF>;r#~8Q?!C!x&TtQOQ*m#mRd2JTVr^I=pZnob zPZAX+W#pvy*+vyUqo%Ae*y#J21L5H+Yn`8(2`q*`$c`)bk3L;OS`EFHd5Zs- z5*`zi@bMS-7laHa5L*+~tj?PgX2bc5?U9+X>93nUV1gea%$~0EbnlF&S?r8K$H2hA z#IzjDLe+}tGLIyY<=Pmp^1e8LlX;)-OjO$+t&i>XrwfJ>vS$>y&{EOTiuV?Ny8Oz| z%bPrPkCZnaw(%nm2UaAPiOk@Ax(cZve)w>|PvEM5JWks!XsYh;r}!xw0D( z8JUcAUgZr&xu=+{;}xd%=f}3D4}E(-}7L zM;8nfs6h2vg8kpWuRY)G+AoSp%XeB0VX7O2>eL4Y-u=0c&Q!ZSZe3q0Bc!8TVZUGR zZ+7*NN&7rfgw%96e>h*Mz{DgiHul5cQyG&je*4`w&HM61$NS=oUJKeuFeXs;l&waVICU8=E=FDjs&EWos`P`z_1Z`}#@pU|2WpW)l9c@nTDn}2pJ&S>3 z5wN_6DY;#MZFh_FyKFy(WpfYN<;iE8xb7|WR3uYM;Kh_{);I(u#~JE#;_L?$dw41H z4FWp_8z|QPPDyl_t{EC1A8)_h%XhL6b%T*p#Vh}3b_M6$+??0d#Zh~^sGEfQCr{dt ztFlBMkt>buGljXyemPD+W_g&Q~B49C6Ou5twXr(5+`sl-0=OMPk3Zl}3s)Da(e zp<0uCs`sUWPIN~U z)%^9^wFvgz2q|d4)f9qTDBs`TcZl5`(XbxSs0lW)#ovk&QF`^$Y3p^)56OA#U4%Mt8(T%mD)Pbv%?!`P@OstE?7^R zfcMrE3~ci9Y^y%1Xn$*3fSQ_mrfz3ImQ$nB;zn`$qQKR;p!JxuF1f-~@BUsvej7N! z+}%@X-Dxmx@%+KA#$ikX9O13zwfyx0FYzp(SRmD94)xyxoE--)P--xYX%dgfFis!3 zGQ$`&zdm;_u$B}G!OO0?I6cs}E>J4K`@DS$3_V7P9)yB}wc*U@U|hPT?gZ8bNB2`; zvsn-GS-b3)x(VFAnGQWWj2$D0A>RI+vbqf4XIbR@bw-Ls>M^jGt=WF%1sS1limL~w zIrYH{KeS-!{QUXzYkxFM5^hB{9UE{}yXvGT(IVPc^Wg%6l_t5; zx6V1IJ<5Sq-N175glfa$`AVx9ccqX|q>t*0)uviP@F9sqx!xm%YV^0t%LOivGu6tC z*3%h-q&R>4*V5i95Sik9|NfnX$LSmat&dI%cFG$>Tn%6Rc4d=IGWm{Al%}}X*SbYJ z57M1-U~$cg1H1F4=JjVxXxdmOv4cZHdD#O(kF4fjM&N^_=^+hrO}=sw;eS2=_YH!% z=2x31*Pm70zW$-J!;Q?=!=)taxoanr*mi4Qc3AFBX(M$nluqHMQz@1Ne@RL4d7f5q z3$Tc|RWBXw=RhvU}aBs?74+=-F`TwH1?sJ^5u9S_V{A7^UI zF!tq0gKYgOA>$#Av+_qbzK{zZkXd2(4PZ_iKZQa=)l=Nw-gxkO2YqLBp3DUv8B6?744UApGc;8Zw1L z#U&*vzCi|H5S+-_gZl=e-H7@mt_#ghbtL+^Z!4?Z+5#TO+aUO6Wo7;N@k0S3owvJk z4LUwF*QUB*#N!=ib+-5LYK!fqk4|~224xCmL^oNiJXaY@b$eF2 zS{Kb@Rdejc!%OR}!lO2`_6m@oO|@Q&fkDj7%$;o|+inHT+#K8Z$7e~}apkZ}fr7aa zfdLwh429PL31V{YQA?iXu05u1*@oglq3adtl5IMi&{>t+Q~s_O!LvBA3>rDV*HNgi zKj^(>G$Tf_xzKBYlFzv3nS;UDEMCFbDDycWAz zMgUxc65?dB{N&dc%fu$?P7DVXteaIfs!UgpYU>L=^G4gN48e7eMs7f>G{V+L!``r2 zzw&$|)fFkFXS_UMFrB1w)yngYqrh83=OVP}LU>!~1{CRk{j96h+}W`s0i)s#D=mk z_hHJuy*u2K*`#@CjfwK1nRvkvVuX;%lgof2Tc6NRC~%1(H$2zWFiY&1#d#1%+);iq zlXLDMN$Y5{O3|&uGU{@#57udCx7_R6Hc88y!p&Fp_WPMfje-w+oI!?%1Jj;E$qHYm zSjyr`cc%cqnF^|Y<%kWN((*z~zDKjHR5neUO~2p&>d)?np3Tmm*YGiNWMp;zASX*I#o(m zqgsV}FD0e9xt2_Tv_#SOmcuQ^%D#_VJ7?~_N`HLT=NZ~;P(Lm0Yw^| zl+@JQyNeg=p8HYh3J4`adh49qH>8brEft_8h(KR5R>hAxiV&0!;3;!MZ$i{W(LhMFmtodHClF_b7kiD*~h z%?5$Cbqt2ny5B`W%kWms<%;l^qL3Fgwt`JotA11SAvXyGe;*_U2deiI{^`A>CGW1J zudkpGM;vtCHvEDt`Rq@H#PX$jcU0$wWK_b#)1=W4)|67%Odm^p3{B~*O%+D4y^c$p z_*7pW@~+(2`3?#Si9l+@AQrKza*?{4^3MRWLlvtZ(+|EFyTFuK21~tVv~e}o{SQzu zKCZ+N2TD*+VH|D3{By0ZEt9|$+pD?8;(!Bs?$2rKr!9kMMIM#bz zS8_|`O`rBodxKtW=kIZ5$tyw3Q^^$CZ~Ek!5jN)9V)rc+CsOu&PKH8lzR0z`c5*c_ zkU-NHA*uP@;;j7HZA|xnEyZrSbSsNW$xCjJ^rCrD!JNG?g-)h;{neO+679uhZD~FR zDl5dYU}S284S5gPhv%LYecC3)8&AP&$M%fcrkmRnFt*dIPk*aWr<%Z2r<%erp1E+` z*{lGmT<9k7Se8Bw7qIG#BtI+C5K(nQjP%i~v3$VeKV1R0xta3XYT|`vg~@S^qk@TR zZ}Kb?Y`@S9M^W9xL=<`H@R;SdeOd7wj={|JyDH{FFE{dRJFf;-b^o_P zR!KG1k1Cc%C7c~-P;H47=Q-DV?aU1f7fi!?G7OqNBse0J)BT&9P0W_-SMM>;Uu%hADw2sY6`C_N^LE%nWe5Nxj3FL zHSS&Kb+$S>Jz$-3E5NBYoe!+#*Ei@!c%Pcu%gVk@V2QMNx8(TeE-a(AnFf(-t&K=~ zH|vH@kPEZCufop##&+hK0+Rc~ujih%Cml=}7i($+03-kJ|`!p)WE;cr@P;JZlOYTaijc@q39Z)@1 z2Vq=h(Z(R|RN#dM<)U}k<1X0p8OC!v0vsSCI}4&N)ln58d*?t^dn#W z){S+9L5vlSX6%NYpV4r|-}^5b(Of5h9H}N$oGG(`j2jXIdGXX*D00)XWO74x;}qxU zHHDfw8GfDLF)w4+7;%4^YscS=3jE1hJ4IW)F}gD=HRs%tOI&L^ZfweAh}B8DWo2}) zC`onO=Pca8QykH$5M*egDfofkLiH#F|HyKZJFb=8!Jn?$qSSU?9U?>JeWdl2fbL{I zPN(<;WDZP1Me-^`gnVkgQrG$M{4+w$p+*$4+K#~(?de>(A|0=>!|AKd$8E+(l7=h$ ztkzS3pD07hN@MIap$Y}SKRwod;8jOpQw9Uq-3cJ$7#IyLR@tX}CJuk~J4#J(pbE@O zpT>4F8Lm5*yYs7l%d8>6N+x~%JJ3xyt$*=xgp-LWa=C;evzs#EQmen?bY>U9h8sc) z=$|t)ClW_Z_s=%bnbuzQ37D>1_N5k0yDsB)7>2kX(i;V_*^q)*q7fEG`m;#GzEaY4 z^qk}A6J6wLE)8Wjm}Yx>Bn%mAvoSUXRM+u*9I|dO>7w@2MaR|K!f}Ku#U9dK?B=m) z%=09%jQRibCc;=d3UGoe6&I&_<#cjHD; zEL4^Ek`SDX)A7=_8_V!us#Ab0k9y*E9N0G>ZX}f$b~cf^K44p;ayIG`hsL3&e_GVY zWlLsK%2$2+mV={AfB9B69Pwif0lm7y@tuO{L_=gGQ@Fp1#|&DiDKg8|+{>s-=g-Jl ztQ0#YU%eGzT{r}HN$x5#_ZlDjdKBmPVGn?l$NyF~1wEP}4V&?TtuY2?@%VDg9V9jx zctRm^yp}ut>9|*C)05*zk&*tNqVPqFJFtaY5A1yQL+uvPbdAx~M8c;gvonH&1|9zs zdC02m=`PCgU>pL&ZKCI=Bn2{?W`piJ66f3F|L)PE$MuD$@PU39hu!8QF5C8n^jf%i zZ|ADh1OWiEPB_#q&4VRO%9umGV7Pz^PzEX|9$!p{sHVNX zB}uouS>+Bq{cswX7(4!K77}4Q^uklnplgF%&(+)5LhWq257KNwJK$^AxWXXxBX#yb zxx=z;Bw454V|tDF373h8zyC7P)z1526nzvKH!2FY_eX96=cl8ic^2H5)!G5~q{c$+ z$|hSw%@?}~G;<^=2&lVE`w>)@o{uiO9;hmO~M)Jnvplq>7& z$`|?-9p8&rB9`7l!^-^Nd`||GXe5P!b#5+4?n4r1{e30L=wiR$3ANf1+p8yGVVEbs zuA;h8;@g?zB)d8MkWweIo{EXD#`?0?^VT!#q6sgNFL5^EQ^ z)J?D({v7D@)kdBBJsQ_>`MPF$0jeUkUscgBGy$qD3nXpps{i__#%$7(8v~BCV5PeE zmzk1rKl)wcU7I`<3qR}Ypm7^|gl}=^rnz=Q;(->V5xlo{N~dHDF+lMy`*(y-*FQu5 z?dkr{ZdknhWumAg<2rvlkq!0jt=|W@#N(u@YNbSdh=5}OOM=O!pZoZX(JIkaTTMPZ z$@IPyBjTyt!jXBH6D}SX_K2$t9z&P*?IMul!RP)`eN?+S@^AwNwX&6bC7ftn8+0Ax zX_4RIx|=fyLr_FP+w1ZKQg^|T+NXctP>!IL&ff)nKBn4rFC>w@>uN^??J5%Y5j6gf z6{LiD=4vXD@)K<(rSQ~mFGR)EotjN9cAe?#LzX&l2+0IeJb!#K-~0K6E+>bv-tC~F zBZ>%kjrn3Hbrso8QUp$(8UWBktFz}PeEAsMCU`6JfBaZFs)TTi{c!W*t6>+i2l9No z5Df~N8_RJ&}1%Lo(GOcKagp?HN{Xt^fBuUOr{6cdcQ5K2G zM{u304jNYDdw`X}U`T#Z`syI^W3LEy6)Hb7C}&Wxif2?T1~Pokbrv!l36eN^7y%UM zP5vHAIGh1(z+Mfec$)Fn=ccX#a;Y(_?^=SO|g~9xB50GHHuViwj+zG{^PFvaztAm#}ZfP5h4@+i+ z01{my8`3uM)fP~qF$SC7S1GjBwO*inaY$%Xd3@{N=|5H`){@s7>EhzIcm=KKHhv3W z^#B}VZ@jm3(3d*df=y%C`q3E;uUmv8I^ww>fEsuWN^50uh52}NAk!9yFI;%M&h0Z9N=kd>RKA|eJ zP;}9pU>k;<=AvoVdkGKa$doMt1MiC6kYn*Q>nYL@Xu|I3QS%#-oG8(KRuDw5{DMK2 zt8*jq4+3#Wd~@y{8z5yhPNzE>pEAE16HDXY_e^k^Yi(BWgM*>9X~0L)i&Nkr)>G$l z0~xcQ5cCpo10H8a#Z;cWynbe-$(QY_a)W-i{Nv-r2K^X~vhFjbc5M_&&bNNyuu5)$ zzrx|6YyDlK46csWmhaJEFDI>Abz9e4#wi%}5a!edWS$2~A9wdVf-R*>QkbXmIKR-s z(X6*xnaZ%!I$_{?v31~ZIb*5C8p%jc$WfU0^ZkO^qKDpxKOr*ZnVjin0knvW@C#M& ztFGuqWAfIItAb4pg=*!4(k`?9HT03OhA4fJ!TIgu>9zD;WoD0fuL68 z*9*7ABGr7gd@gV`F<$T8M#`rS!pQV{+MO1BBB?|+*_c--N;m4uUwDi%;D9M+i`C{K=P@r=6Ce4y)`hXEoF!XAWc$eG&8QmlhhLHV zlXTk>)oftx<)+wq-Q_8Q)eLj1c2E4f?}^Df&Ggr(PGaq!5j-{6;UDSWWFCVW{Ago5 zbz*2kBwuQMtUR8wvnYxYePttol}E{OsG28_K4PsqwMSk-nLkOZ+=wMX8aO-v>^r0S z)sEP!50&b@hG%9T(}tqy2Ho&gPG$a`NhBa*KQ#A$5)n;B!BVe{OIYQ|VWKZ({Gy9# z+@xydQH2NRyWW&eA|?m1HY42xrcQGFA^PT!WxH`&!7)kxq%XPu30XwX8MS`O_+0=R z(tz#pJ;I+dpH3>@n18(9 zE9$X5wEU~{W{~BI($EUbzhhdSuY01#F$+){_>80b8u=f8!{Dsx(n)M20-SmT?;mzY zk^>d#<8LJTK5T>O_Y?6FZ@$jR;FT#At)g%-J=vQ_gYcJGsk+pT|BdVXpNp=B5pdp^9QwRVg4 zJq^a4dDHpB))Ox#vL(v<`|qDpKh1dD#dL+{{N48m@b}~l#M~9WEX4e^pJLAr5Z5(! z3L&kavuQ7#N(Pq?AG>3!BBzq2=rWJE@7sb;eQi7nPk$8vSwp2hGEaV^8E&bJ z*2YvA_J@x8BtW&!mZu2R2Y9@vPyJ9zFU0yOcY)=Ok|u+gc|`%5M@|LB@S2!dc}E_T z_5>BQ;A64iJ#Bz-86@MkM-*g~QeW7y{VOc{B8mg1Rk)GDZ@x1lqaQrx2fOI@ZN{~CUr2KOyB8Iuqp-#V6xkTwh`2XF}?D9G$OMpWeP^u^H ze)j;1E2e0d;F~ORd2s=Vt43nkhsTmv%Vz>twT?^O=?0RN;tzFW^FMw7%{v6(BA}|J z6bvf4vU->2k$mozu^)$JhqhQ=R@=3#I#AQpkGoxA*b0cXUx}F=-&19h+p2{k_`GAMLF(b`U29DkEKi&kTo&1*;3Lj{T7t15Z{jN zBacbD+1KKrQeERc7ZH|~Uf**#OnUGq_SK6OUiIykkvU=pnTbIWE#8V{*3rF7&nG6JaY8K*rc&+Ep0?-(`W)&w#WU+bE6f;g9M<>p$k8R1%{tyw5q2(|ic^=E?t#D|eTpir&9DVz{ zvZug5OS=ezt#`Hj$hH^$lFv~eVA6W$OlDg!Kv@&!_AarP4qEXX$Du=%j`=lmZ7SpW zc%|hVsgu^wrgMmu-2dL!F^%$hEbWjSvc|!6Ao^X?IB*~OR=Da$ZC=c3ZZ$izQ;n{k zQ++i-9zWi>XqO3jh&l~(m%F+oF{OVAU+ttD>xe>;L#~mHpmL`PAUaok?xmh;#*vi! zEZhmh*Zk>w|H*HCU%jseYa9yz;qh2tn4-_n zDUTIb5?it>3Z@Nt)@iD14I2*XsjRb|x4ArbUG%OSF2qV}cZZ3TPk;PVfN@LRM6&*q zU4}{}dNvD*;o)QKK4kE{E7V>a9={EM<8c|!UuZ~6X%!P&b#aKd_PE1pQ4iZi*%)L} zdzLDnH6I`XNZr?cyeXr}5T+v{ta6T6ZJA@%!hhYZiX z?#I;tB=zn%zvs`=fLzj7Qe87k1}p0Jn-jAhHMT4za#5r8LRD3f_Tj5}>T%~3c(B2v(+!w z;&}mhzQ91=^z6!e15Iw&B>6?7`k4Fxn4;=hlf)-ZNuW!x$K*94>pC-=!O|8kVwk`|p+HB2_MSyzZ$L=E8l!l5ka#9#vCY6_(m-izf zY^hw$^;lr-Pj%jnn%5c`R>@%TD9MF+GtESZO#4%37 zt`1i+!=Jln>zNL*eKw-}>d%O?_-G%)HPfM2R6>JNgfoh?Fn__#XUaQR8NSU_pOBo?*Ew zE?`W2sS>HeB$oX>(_QA$qv3jAL%LLKKB8yls{+}jtR2JtgBB4K=2`DgQP9~M+-2j$&0N5A|s3L z9{K1{^c?VR>sg42o^sP?E>X=ru0NLn_QM)#2BlC1S4VrW}qO+75n zPtZcYEs7k0qyI$5I9lsUp2%JxQb|{xs?n|#v+3>$FYc+bO6hXvYpQ|L2;$>7w7k@o zfl#`52A|#v5Qpe%1bYP%g5E3y(mDY@7fA}n!fs5}j|0x5oi_c|_imTxsq<|(K;hS4 zy@&qEJVzOzfKdZl^6nHK%{so82+q#OIMZLuADk7XmE~icIw9bFCPO(-3?H#%(WT5% zXw>B_a0dws9WVig2Ii)O&)CdI>;l7jJCN2|-SXiom>f#wt&-DE9qtPAdPwpoomyij zNjEDd9+~y#D(}~bb*%(#)k#D{D8dMblP*L<@fLI#BokNyLo=b;eA^%}+_`gy!%DM2 zBz%Nz-H@PteKd4+@*6(ig~LHa1aXD2+ku(;Qnz%6Bj%f&YcHuiR41Z!YJ6X{AVoAy z%ryg=*fcxCDjL0M0`iQnp3#_AE^Xa*Kk|x9DN5i!F-WeJ%jd|JJplkhy;g9Kq_hE4Ej%|0WMa4)UY;MnRv>DPH(Ew5an+k@*xzF|u>)Ff<%0`4b%ai7zp zmas!BkZ5u16PpT_%kxCct2m3qD(80 zxj#%YD7TSj82-k}O4`G*ELha>sPQMgvg#!nU7;N_2QM@_n$6ijWtC#eQwfgC`W4=m z;H%)FBexW4?teiQX&djaPk&n%(TbTr4RVJBw;ou$8bVw@gkBy%Y{OE+HwAQX>&%byAsMxk~ zI@1(Q6UnNBHwiUHPt;}tXQ?0g>1pLh6UUg@UGI(@@B(qRw4SMo%m33$=wzqJx<)lM z3{f4F?|p@GSQ3h-N(LXqhIEW76I_hd@K!2GqWnJHi!iArZFf271kU)62W|Z2ffygR zqP;to6sYN*?YdR{J;pA}sND5LdoifCDYiJI7d$%#UT`Tm{9?+EnP8kYQ$QoGtulD^ zcQFqt{fj$k7ZMzGdffHdga0Dm?F9F)b5)A7zSHtz#RbG($h23+5&0*Doz;~DbUx0^ z7h4z2?r}m@X^}t<7de2$uq46*KgDLNs}S^z)zrx{Klpnc<9F>i z{R$)OR6_pNN6$&gpS(-*p*>|4byX}*^p5et&O+IeE@92>%~GX(4hY<9zD_#$Vm>_j ze{!1|7NjZ-e)g83Z;cHdj1aqkJNow?qT`4Etl?uDKl+T(=io~W`8EU}!z(*ZJtbVx zreWoxR3n<*H+h&uMxFfa&1e`dHpN8`)(b!OT4<5-&^`NurXc#`sNZ<3_dedddi|S9 z2WjEUiKgWI3E#2Br-Ht&u5~fT+L^w`F?(uCM>Z_7zI7oxcXk!)Vl1v9 zmzJ||mpi(y7slWH>nWD^7jrvbbbg60XW~tfd+V6X0)WpiC5=PkdqlnXPrA#3ELiV_ zn`?sFhn2p^O%M0fVy@=nOR;(Fm`^rur?4)3!&&az>WE_kG_t;;z<1V7J(fx(Ved-D za7)~wKPU>KPe!W}6VR8VU&u`jm+!6HHWBv0Oz-sg)0+l7_NT7R0;UxL?sQyO@JH>z zG7Pcps_0H|*H^aPs;H#Z@f0p=qLz6e;j_KFYs05v9K_8STPpI|F5{##&%9CUuWmFed7Aq-A=7tga5q*jtHOXN-Qob zW5nsRf5s9Bmk54Uu`+NDK3N~$@k){F_Yj9$9vj6l79rF3%*R|^!t;S5AlI-&aZZ}jnf+aBUgH4 z8VB~>7U}O^4tTt7{0JPNG)EY6<1{+-s}L}oL^+$GQ(43R;;gpjO!tYr4g+m#H}xu& zS~C+&KZWA5{$T?wNi@iu7`Dh+(L7i`B>oBKoI&sP>AHGW39*MiX`3eWHO$cD%xMo!i%trlJ5cky(tUc zI@+sf{KaYc0ha9Tu{S>Enx4l~$<&LiuH+}#z`qTY!G3w@^gWCc4Xj(b|HPu9($L3M zv?w80BMH8LvrSOvp0-kp=;w$0Nz^t{@ARaj2N9tQaTB4ciyDKm!nTpXwMcs;%ggnQ z{uyBd=YP2Ej0Sev@`z;}g6^%z5VeObLamjZE^Mq)Wu%O&{RUB*P7|MoI) z$O=WpPxZrJF231|*)aj9qu(NFho@~_uG)rtd2{-Ae5lo~xvGk;epZpA5;;KBRyi$y zLc`C(+JiQ8;DlJpE?7RwVXYKl3L@du2g*&l4>F(ikvt-0R1AvYw`Oo>4ifT!x)f+k zfzs44!a5}E0SOJaHbgo_o=oUhPxKw!I46vhPu!h@nK`o1fNP;3BU7*~Fzg`-bO<6- z5T0TB9pQu7fM8XqkQo{rG+7>uXU5xA8W>2|ele4;5W6uLhb2A}4yb6flny-3)-Q=#Vlju!)=W*Ydm4&-AOVcLEt8AvwB+io*#y%f-}a2MT+ z8wY`2bGvz82uFHjs8kL=uV>T7czI8aqOcGLYG|yVL?y-U-Em8Co^oA;9l33iAf68@|z^Z1J2*aUhfZR`+#2pF+%^Vo9uWeq>S(%7J&y zpKfoL%?&Un$ITo?)bzU?E+L!gW2SOV80m5zOc0& zB6X#p+dJiP9!zt~-_@{oJOxs`wlK^>5X08Cc(Fe*`RsTCW_g;Y}g8I5Ujt&R6t}ql8hX5W8yr)VeOnFo?`!+XyI` zO`kl`6&}tvTWD1HBz&@=>vO+;=L(jMFFQS!-WZEySa!CLH1g&;YKN?t(x+C1lw+Q zCqTRyMlyZ`E`hBzZVL`Z3Ku%4=r9Qe57x)D07yOoLRR}F3>Dnh`d4C6$d^a;JlB*Y z7(c`!9##8m0dp(kqe+!DzJ12b_wzlES7@xJg-HT9ny~-AbF)oLN9C0Qq=m_c2%J(KD5N1+%RzbYrIX!G& zP$!8B=9LKz2EbE(QySV_NVIJOToDOr8JxtwKj#rZ0k-6j{}dz#Ru6o>NeIx6A-${G z)`AK!oB#ZiHEi^j*wPM9?Z4_^AtB{(A?A+|vj<2>Z%Kb82oR<~n)vgl&XHU9_4D`M zdVx=Q>5q%y`q%#!kFtljfz)u4e6VwNukhkAG78+4eSw|r|J3~NOjz@i;!*T8H7y=CM4XJ;jy^Vqr!*tag%V4ki zv`G4|W(iP`n}gYECMI_&2iNEY!Tdno6~EY&Ri1py<<`|)G&@)k&yEVTelR}?I}+Y? zWTU6|ObpBIVr2lTQ@wk#)I)~LKqyU9e^m!`!q@e9t%K>+yBkcbP%xkNrz(#~Cj(vW z?u)H@g|W4!fTLQs10)72${wp9xg#whXA2usHI5WOCfS)J6iNjD`PDYI%nDo%)jdGn z*uvIZK%I8AoW@4@qsr`nP2x$2@vks*V)4BhEz7?v?x?)GEu0Eyln%D0nK_(jd2qJ1 zWvFg(Q?^@!3o|0shQ{FtzP6Li$bkdF8K;G+f>NQGBhYeH^(J#gD>KPuw0|*2q1+^u zULAb!HQ*Lf`MC#1dqrDu5?C+EuNN1VnoRIuR2@y%`#W?Zg#H?`*` z5(~b|1s^o-cApWD&dB|ijHvtDmAzS910yY2RbaM(M)kRlqM~=~F%WCC+cPfrlJM&_ zo7;IIA(fDMAGne7Yb-T-Nq`B`NT9dV`TA~J{ss~YPW?WxH6+p-|7G)gvhJ{smv@b} zJ9GFL-t)bl8M=XFRKnGq4k1aq0ac;;=~rtyezSt6sr2OT{}M?^s6O?iS>y6B>WJc- z$1T2Ml1^<7v)F2HZ}{ zLd)3JT78N2(G&e|-E`EjsZ=D(P8*B52EhIIf*}fEV4y|ivON=QHJMoMkV0z0`hTSl ztO1%u{v^!f%Q`)3#9qk;pNt^!&ygKNVA^mpjh*9YC!k;m9pk#ZNRf*iU^4&d>EiMz zCYjaP=C26tL~MV)?T84pJkRzU{iEARyLxU;niP|M#$~g-y3GD!u7ZJvmL-#rW+p5- z&&gm)Vn=tgLJaFNI*w@pTF;-ESR#{mOO^y9me+K!;aViOS`lXg$@6j+t}q#x$qb)T zpajCjIKdVg`zfNe+qX5VcdOUvR<;Pru)X>MM=MO7uDkv-9A=7$g^o~qxoR%)tQ)JK znvYUR;IcPa?99#zu+}k+ZPn6$yy2Wy7l7ZTtMtbH;U=sfzN+Ft=?SJbttwR!?gGo%n{Q%d85 z^l$9#EgZRCCJiFk(FfLjgvDbuodftU9C)>0v5X|I;9Yh#4}ePbaz4DR(sU@|+}BZG z2}{vR)Vr_3>H^D5J z#eGfHN4#jZCNga*b8*@_yfsmFngTX^XXjs2i>*4NgU&C{D7cd=6cX9;7*H+3RO`;0 z045kprIpJF?ESTcq_^L3SDs2-MyC@nOI4U&2r^P7V)Z|pZW^F}Plyt#tooFpoYbUb zp`tZ}=ht4&UV{(S%UarT1JM zjyrJ~juh%zAf3r>{I3;XyQBm(ErpxMLSDnEK2;lCW~*Tu3PGfRfsJ67LfPaww=%>01G@1kJrD28}m;{KvQMJ8INCGo+~o20{)2y?uQYOZ0hCCTQ- zQd7Lw3w>#E*sGn9#hq$cY^p4B-<(>&s7Swm5v^9he0e(L;Q6UnbsTjDlq!^${ z5GGX~0o0t)uQ%Aa-KY^h$P&*$S4OiXm{KW-B{3XgBFgT5_>HX{4GoQ6DgROEnd)hC z(5-fno0|g63dI@q#v_FZl5oa-+}2R{`O>z{NlF)>n8srwEuw$_os?m)Cf~TclUH#) z;)zz?OK}ME=ks+5xAwyrBh*A5S+%qP%dMc-|NOrI?uYUDM1!`fiMt9&Tyu^4MiM!6 z1%Ort5@`ft9A%u^5SOZ#QL66c300Bv7Jd?YfpHym+ZJ7FfbQ0bP@tg8MN^m<^lBB- z^cQdh5H*%l&gKXie`F;6+hDA+ETGfHGWR>QyScJU9@cdVu5 zIP;B8tVy0Kqaj$w|5!)XhK3|_og9FW33NjRsVa(Lxp7O$UEPf?@Zkg}Q{wrgC{2ZR zPulZ@dmPOLPk;6303J?ug>AK!-fU2~4)-4AY|{()W7c`dR;0KOCdGy}Pa0l=!ssCl zwilQ*QU|j>)}Wp%O;+>)!Wvxa`(O}E^d5%+?_t8y4;3#&MslqJweioyG0k@jvwajo z{wLl4fi*>q0iQqJ#)+^DRLKTSvA(}=mFQh7{22M%ZW+bn<9mVIK0dKbS0y0wjaT*2 zX>rdDX1mLg=ic-~ajy1oy$U1Q1HT|csENCpxT>`8V*uq~Hw~W)N<$5`=!m~S6kTBg z7mcYCr~nzYC)(@?n?JZHooa8*|2j;Nzm?X@bE8o`)>-A=KJIX&BL`3q;C}U9$+XVC zIndK>WMF&Ds;t{{4R88!<$=HmXzTO6x;OA7 z=9O06Vc~x_lNNtcW~X`8J5qZ7Rr}$iz*Z?R-vlu?BQ)*^0>9^hN`nf@NqQz(jxe** zVudX9(k#4@;e@Dbm9d-?6qHZ{+-jY|WlwEc`X=Zp!P!n0?oR$bY^rTu^~Ma1*Xlu9 z786F22h-sgB4`UQWgxO%hY1aX&F1YgD3TR8bI{FB>L1?RoNf}6)^6CGeH89##7iG( zB;6qh>A#NV`NNcSO=+cQAuO!zJF5y@a}oT&76y0Rro;8`yn}#Dh{HTh&maKN09{&k zyu*di)bA+B;-c|#)pj%^sChaA5Q~UMGj1G2q@;KcaWq(BE4E!{})97wieYfdQejT$Lk8Sc~E02eA zZNoz{DltigWJ%dGMTjQ86xkA$#z-SF%9c{ZSW_|>5+XxnP_hlfNtQw7D9fZQjU`Kx zVme}&$okz==lss^`+n#AGk?6xGtc|H@AKUEeLdH8k+C~D#5xkMC-v-aoJoI%qUa6Q z^i=-U5R27e)0YZaWfz4HifkP0vKm&2vgTWtu??n^fduEr*(@yv8r!n zXjo>wR@{-I4wiFj52~bfdksPMUo)@Mqs}j!#F&>8P*{!WNeh}IrPg$Lm#yqG@5dPd z4+XcbJNfvy{cs~UU)kQ|xs}`K+jM1Sh1Dld546d1x^i+)j@c@tuzzZ9=7DN8;0djG zC5>8M*~*_hRv(JC$*YDS(Y{YkS$X%+a_F-%chYx>I&W>=Yn%}isn;!rZxmc#OWVWC zZE7fu7q2F@k)Qem5rk#bpHy-7>&w*5%!`ROno3k1RWRYV$u`joaG-IBW_zOdi20do z-F8K(H5HrMz589W`jUJ^)!KEg|EV>+`lX-{Rnd(qvAp>ua4Ku!b>`rq>IikbWYNKw zZ0*^i(Vq#;DQe-S^^;=~Z$sXwzrwJi!or@ zt-{1mt{>fTO<}_mxzxCu1UL0E5Of63kNH=fZ_U zR#x6A))bK$Tu`aUK@YIY2!S)-y}W2F^}}Lcw=-KwYA>;kL(iNG)atT7LI_9ev9DiV zBDuugYfRWrOUb?X9-hvkCi0>90ce&~UuiRbX+dQPaZWG;n-2Nr_Z=^^w{< zQEL3jQK(?FLFcwJUt2byUF@{?&fXiX?RqbLU)=5PU`U_FqgIMGIX&raV@e^8w4>XY z%KQJ_gK5&Y9f`r@;W~3cPqAezC@>=XZ&L|7z9zZKFy&4ax_m4;QO287r&1ggPQ^H< zniVVc*%l;cd0err644R(`N%}veW=_tV!#^J092>0eUmUz)#)FADy zK%nK7K~9=NUOXhw$F0nBoal=Z)+gz%^3*d8=S>{+^xg(}`(T#GxnWrlcbDW#Ho$!A zEIaRU)Z#Z;LcQjAn@fjeHO@(CWijzx^=u52(lx!5Ph8hgrjajUNso5Ko3&XsnqY;kkZ==zy0_PL;qPO$iNoE)(ZwaKibOuk~gs`P_|3IRs+s zB|6I^fv@gFK=2L0uI?ZgDiE9?h2nOy?_Tyq$p|3Mu7c$`vf1|2hq5Mv0=@MX;@b~x zayqn0>1Lr{SN@(sqcA9~oKHs4)uj#VIb%V~1T{PeV zHl%s`sh`mgC->E`6fi=FdUu)QG+nXnhn9C{Xj%zP6FCiU-o%%lTQDz{jf!V^2x9Jt zn-r=a_7z3)hU3)7AX?ick}!ZI;+Ku?vDC0mc(mK&2eM7<7t-apo)P_AfjKeJ+nL&q8n`WS&5?q>H! zE9>)rk~OTA^(qItpnWN5-{s}?fGH-wLS4Jz4SW|LXn60%ijx_QEA3IiegFd`@7lWe zqJu|!&UFeb1Bctd5Q{>Zgcs{()fXS0)7+UE~t zKMa2M2KguG@xhKJ8dkF-WRM@RDDsjBC>%o4pK&c-HkR^C?d>`YfFD{z9oL1!JNS?Y znr?J$T1)2m`HmwKBTpi9PBc1BYc#5PN;B)P^aa`Yfh=ay6e~#DW=L-vZC0E^fglBlY+oVq4GUV4kA zmO%INl7$DWSVCOfv|zVxQa=Vls2D)dUkkbL4O-8Jr@ED%nKzC zCHcRCD6JRQlKT##U0KV$TY)O7{{|g+0NX0BCOw8I=y(zZN5-6Gjk<2)Y zrplSuI`7y12v&0(PO(m&ndg!aX_fV7G7&xJL5VQ6cj^~TZdFxpZnc(?svz;VMfBgc zR9Z9s!2JCF*!~x0W;mn4lxSZzSI7#vxD95c^FWqfuB)#|lsnFCpnzgx7`kk#ssp$! zaHV6S$J@kK0fF(wixHi<7v7)o7k!XJ%O4prsgOc)db%Tj!s{w{$7!oz)r2vrCiu;921 z!S7H|P(QmaCd0~B0Dx&h&T-g+hI0eYw=kCfkyBB{4`D_qvv^XEhE>(p)>ctbQB-u5 z6gY@-u^P!8$r~vEN(E;Z&5$^w+$9H0iu|Y2;XK>SSH?{iO*Tzf*uehdH2zqhm4!vN z`I}1R&Hr;2%*ck|tdeXm=6=K%>N#C#ILYQtOhQURb^;Aw8`M)#lc9R}vuu9PV{i&H z0^>8uO_j<4Dtf9v#=)X9sD3sRv@?1i`Vt@k>5Vm;fx}NMw8!vX%&KM*>zo+RDRt@i(JJie zvSQ6)uF{?;o=>XZW5xc0A{ {abstract} + + not(notFinder : Finder) : Finder + + or(orFinder : Finder) : Finder + } + class Finders { + - Finders() + + advancedFinder(query : String, orQuery : String, notQuery : String) : Finder {static} + + expandedFinder(queries : String[]) : Finder {static} + + filteredFinder(query : String, excludeQueries : String[]) : Finder {static} + - identMult() : Finder {static} + - identSum() : Finder {static} + + specializedFinder(queries : String[]) : Finder {static} + } +} +@enduml \ No newline at end of file diff --git a/etc/command.png b/etc/command.png new file mode 100644 index 0000000000000000000000000000000000000000..0f026464ecc4ad0218a06f388d259368f971d1d2 GIT binary patch literal 51106 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 %d-|A2TNuh`Ty%@a2^Oz=yM-`RNka~xT) zK7FhX3ZBg&CvRLFPPtH4yYxvWc2#ci8+_L)!g#E7Ye~8x>m9Vuc{v;VGG|Tb>MK`Q zk*Q{z3OjSD4VvU+6UOKLmT)3_@>Zw}QT8)d&ksYy*cD}^KLpZ4!;+E@D9$>7=I3R8 zv(YE&P;!A)>BtBtCDR|K`YSsSH}w@PD-^nPXsdR*xU$ijjjdy9S&rjIa-;;GP1K_V zU|Y`c+k=Yf^yM@_Ey6xo0}T;~0#6V>IHPiin(6xms-d~1wE5tAhn6Lg{g3&KT1NJMjXZXh?CGSRY>@eWGYo9{lA}$E_uU ztmNr_UZ>2t?sznT@m-^%rH(IwBf|o%YIm)lcXn!yn`G6ArKd+Mc-zV**b^$Kk0|2`S1RC7>n zh6DO43oo$(K3}xAbz~qJe`!jJ7NRNxfCMT9lZy9DzKzs-E-g!bjhjVa3(ksbm3pV* z(W29G67tZ>R$*o`u4D>*_$Z@HITpg-k40=>^ni!Y#qkEmeX%D#i#LR7B&nriUQIqe zY7Zl59qIZpa^K09$mQfnIgdno`5oo0PUnk@QVP|!)(H1yAW^!vNJS$&Df&WhFp)MG z9R4(BeH-XNj9D_fH;Oe4^INT3EmN(UKM%TiL(2D@c^>rP2n>_K{N9Hic2c;f zFOiO;*q`lS)!=1eRQBzYueQev{Um(R8|p^r+tRU6u)oA!VOWD>!?cjMuw2fa$xroHJ}Ha7IVUAE-gxj}3yrh|D=l?#YO1~uz> z!jI!M2P+#hl(ObYi(4q+zq?QjW9;t#sCP#H#NBMfG*gZ;s(t@Uwa#Ln-JA)cN^-&V z*Uu(6%K=f1cJ;~O_AsZ@j%)a0ljG=@4|io=cBYhW#cDfpMchz1G2x`bXR?_y=tj4h z8;qR4D44Xge7n?N?e16VwduFyo|_vSRh}1`IuaIpho^G6zuH<{Lc?KHl2A``XEjEm)8a; zPthrdbaO>2X+QjGe@18%eZDytIH)5XXm=2ZE zcp_8qe(h+c9kCXOaL7=^vlKxc=wjeLH60P>Es0+di;+j+GR>5wzep4gf6L(aTQJog zdhF9sV^E5W1oI?kFK4`?T#aB`u&~+gE3=}b(|Z~8zdk!X6ofwex?le*WUHx@s_KbUw}z)$_I zHGafrEtDqIGK!bYfpb+o*q2WYs>MHVQ6YwBz;Cf!r%j?}R#x8vo0%<`h+Q&>wnkE~ zJC4P9*VJYIT1Lsc*tE!e!)u;&ApuC;62db7eVVoF_Ygk|!5hi%* zxZ)o3r88!!lo*j;EsfuKyvXp`(FNcC!EE0(S`9SCClvJx-jAwLmGcP2F1t_a%Gw0B z3MFXtFBOxQS}+SmF6-!uSy6UzwGz7PuJ-426v%11Z7FMsVZpUj8a9O(-5iICJn4wQ zMcry_>@CB*r*!`$1|*B8(g$NOq+yu$ED93xY_*=l$)F0F=$ zhvG*X5mAM_0LM_Jyq%a#C+pFw^I^L7n8g;a0v|Ex-TJB1^6fo!4Z19J3f7hXG}-v^kw3$ZD|gn|Mw|VY(rV8)t+95lrH3ycHX?hf z*|zzc;pdzG-R_KeTS}_T0pV(~tbxgS%&kfbYsC6qlL4&0B%&Va$Gp97CHtmD=hxxh zYE+bwrn3bF0U1G?l6rHi`{@(G3UaY@3qx5Yh`x^EGB998EWZ$PX`-tqKaCh0`S3b0 z@JNG_pU{f;`r`Fyoh7|urGYQf|B}1om0S(h_t#GS+s${U<{5a?7kLG@$TYdEx!TfJ zTVGbsa}jrRowqsvSRUeYzcHH76D6cmVXmMpd}@BUxE02K!soV2Lok-BQF}BRQdV{7ZyIk>b$49-OZ*x=&gB1fnPI?L;uxBWq}rB;^0JCpL=R64?b zU@@w~Vw^97gzc(;8{(a@n({%2u3@eL4cGV)eP$3s368d5LwC>Tl zx97i{6I1*As-EeCXyT%1@#ic~#1@e@-uI>iFPq1dcVFB-*Lv>dYbscH90~eg%M5-T zQ0X|Op7)It^U1u9v9a-$|Gor{WIp`+l1t>tuU=GBd%d-kCT1u^@&&diH=9?o}L>yi4R%r1={7f}#&wKRT)_D%$wr3W_?)()><>e_~i9@+?7d z`Qz5S+_Pupa1L)72Dw*qVrpvhH>TlPk);wbN>gvR#WlNHlW5u{_R|l + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/etc/command.urm.puml b/etc/command.urm.puml new file mode 100644 index 000000000000..f85949c566da --- /dev/null +++ b/etc/command.urm.puml @@ -0,0 +1,58 @@ +@startuml +package com.iluwatar.command { + class App { + + App() + + main(args : String[]) {static} + } + class Goblin { + + Goblin() + + toString() : String + + changeSize() + + changeVisibility() + } + enum Size { + + NORMAL {static} + + SMALL {static} + - title : String + + toString() : String + + valueOf(name : String) : Size {static} + + values() : Size[] {static} + } + abstract class Target { + - LOGGER : Logger {static} + - size : Size + - visibility : Visibility + + Target() + + getSize() : Size + + getVisibility() : Visibility + + printStatus() + + setSize(size : Size) + + setVisibility(visibility : Visibility) + + toString() : String {abstract} + } + enum Visibility { + + INVISIBLE {static} + + VISIBLE {static} + - title : String + + toString() : String + + valueOf(name : String) : Visibility {static} + + values() : Visibility[] {static} + } + class Wizard { + - LOGGER : Logger {static} + - redoStack : Deque + - undoStack : Deque + + Wizard() + + castSpell(Runnable : runnable) + + redoLastSpell() + + toString() : String + + undoLastSpell() + } +} +Target --> "-size" Size +Wizard --> "-changeSize" Goblin +Wizard --> "-changeVisibility" Goblin +Target --> "-visibility" Visibility +Goblin --|> Target +App --> "castSpell" Wizard +@enduml diff --git a/etc/commander.urm.png b/etc/commander.urm.png new file mode 100644 index 0000000000000000000000000000000000000000..6b5ebba75bd64a971924f4a3f8a2a89b7df905d7 GIT binary patch literal 322274 zcmeFZcUzO&^F17oM>&d!ihziK4Ui%TNN*O3bdcUbr1##5g(6*g3q)z5_uhgaAYHoD z7>Z~Ct`QvW65l&vpUXUapj`QtJj_IQ zlYcFiB{JQQE%<$nwQQl0ftvh=d$%Jh<_0Q%itVD?Bh`ofvoTFcD^ZJT$e%Z8%@bHe z)2TC>yA(cHcuz>v|S^%tUzQEWj#Fd@0TTK?37;EtNU>^+DowBjqTY+b^!`-SpPV zY)>75#tqWxKOz4RF2EQ`WN8hrtjHDX>He7UrSHmPn%%yrJWc*suX z;(oq?V&x;LEjqo=bfK6ai*J`{udT%1j6dgoN}G~!*Y0lg*aP_rZ!`7J>^PQ_TeoVC z`80~}vO~J;b0@-c*90_0)f=j4sX2F$%f8R~SugiACKJk7b6yDdRK3h^r|LH;u(Q3f zB6x?@UXH)Sg6~#So*pwx$5c{$aku5#aK`)K-`d$BdHYQ3>xs%er4(fW#|&y6B$dlI86NY_Hf zre&mD754R#a@uG3tqaT@&NRQ@$eDA}ofdz#noCSMOBbH5-e8lMr*18A)_Rp%b(>n+ zC~wD3ILum;da-*UHQBdQ*y_nbQ8A7|da`CcpT{A7HrXw5CatNdhb?mYnEp-cpcP8@ zPsOy1b!baoLAYXdWchEi?-`Yckn&3o;wCRSyF7Po4)F;}U7Sk^x3-@==9(6msY>xT z`!mqQw(Zh;Zt1n}VkS=!vo%=`*;_@Mcc;&sFY`To8~&4P{tBy^)9?kuD9m1TioZMY z^?^FhFJSdfQ|-mD)cKyfcA>1!&D1=+$(HZV*^Uuu0%O98o|@Uc{`1ebUgtlBv09*6 zLITq!F4u-Cev;@z)J(rn`SPL^{dFPt=f>zys`{TF^M8g6XEZe~+v)ivHW%aW2~^mk z($#tzUi(nK*mA#=ab0=uveenK1*7YCafhs?R~`X*AEc(lUd+@^U66iN`?)B*JE_|I z+|B-n>51((0w%__M^cZ!*=cr%1tF?9cZ%%flb*$lXUvR+TAVj+!`)r2OqMbl)~S8A zk*jks$IPpA*+|>N$vQtj z^s={~I0@7IL7iXwRQK8?$1P*(w~T|3-YBE!VXF7SFYAiiz82b8aa=m7>D&9D_>5sH zGkQGlPX-$An2VuU)B94V92C)%MVDThh)OYDpnid=5_i8*z-T?F{do*F%xaTs@c9n~ zVT{Ij?)*UjQY{7ANx#~Z6OiX<)Anj5XtnOq&J;Pu@`sgzZCtfrHvC&nGLK+G_1H+U zhv<(1i9&w3puBC)JNv&1P*+5a&q@EB%!>$n_{lC$xA2AKAMc0zOYhF#-1PpFPM@~s z@!Yebg~W&g@dVt(H<6q55Ag=)C35KMs9)GN2YOu;uVc}jEVJdak($&aPGIgB6P-+T z>*?g?T(5cYWJS?ln2->`<)o|kPrNLzM|*wtGWS@ofn<6=|14C+;$mtQwIO_yA&`I& z(k6W4`Tia*S2|?5c1k=4xBl8@1RBkzofnlHeR*AfD40`H}D#ltc zSU=ccwjj^j{n#RvEdKry&xsi7<@kog`I|^rJ*U_glqIo<)YH=`{$`n&;z7ZX>t}`B zFg3S8Rl#8{GsAtZTw|tFydnDXzI80mj02sdP#E=|rnY2uK^!%GFSDn}{Re6H<|Brs z3#d9J0Mo<61IC^X_MD)4cpf0Nml z&$AvBwAya(rv3+s_jrs6SX43!4 zJNbWumvF3So&u{Wq5jGoN=rF_cCJ z*sG_5()@vqJzh%ahg}XWx`+9E56KOfnTsTPS6U^c1mjSdwCS#}#~iQTzm(#I2=!?e zy%*d*BgZyeVy-V}$3h_QAaYXAHN1>AXUURp9?p{OSnYM*ic4-Pmx>&^X_nbdAIWnR zc3EJPq48H^c?ZoVg~Dc7^S$(i)n>sp!=9n(A+*qM`8nYb&fYUjl&H|}M4Vp+roDZ( zZ);#+V0)mC5I{T`fC7T`pT|2JjA*yXpaFIc#~HMdsu#7;`&TVsy=Oc0CDkT+%y|lrZrd@Mcaz**cA9)mcd|2${usu$R=kWZ_{3M~ zUg~tAQ}@Z2nbYI8>cib>v47tE*;sEH4>#v%RE6JgL|K#QK+&dzshSsTmqLx@+y#{%q3vGz|G&A)+Rc}!; ze6Gq?=Psjp4^G!q$s1 zaH+R0i}TdSK<9+PTseebn&SoIQ3<#v!Y-s=MzsjWF#;AwNNFwGhenNEweJ+e<`Hv;!%t%(SQw&`dpE)^J>=*92%ms+PdR_-`&A)deU zEc4z%J2gF`F7MHaB1Ge#RPkM8t&5g}&Kv`C?ch$?eX*WVmFXbrMKu{gtD7|GNg9J> z)a%X-a4%P#QO2CDfR!Nk9ktYLFGU?erkqLTt{^^HYitO4JAL#pK3l&%C{%siYo7{b zMUrazZ8k0$w&~qw=Bp%EJkXXB1igV6DG;#yNE}I1dQ|3){06{bmG; zSl}~x?m9k<=Ewe}K{@McK5&0Woms{l{CnDvF>v!uCpR5&rks-j)?hx_H4q0oommIM zD=ki@nO7PS2k%#q-p$s>CRu$w>(nJFkHSNg{+f6jKSrMTa6%N4BJ&TAvlG?g)}zr1 zkWE27&}CsXx7aW;)%A|&QE6gI{2J}G6Io`_oEjm7O8_)GeyzHo>VS`tsp5j)^zq&=yK7U9^62Gn0@UOG%IW96Dqv%~#U|&P(`!M@= zedMNe6qc{MrIy)2o+R9pU8^5RSyse*D*duEq>xMAl(4=Sb`iq<&mHP34;74=N+0jZ z@wM&kK2n#or%gZ{MP@+I(ZPVD#SBtzETj<^1Iv;n5lK0&r7=r26zhMqJ5)_Uc0kOI1Y zKp6dJL3`y)ou<+28gTADA=eZ9CcjlV71aFl_Vqtj}woh5!K(`xCyDjTAC_%~`* zj=o>d61|MUZ=}H~lUz6Xn1Z6M))8B6U5w@(@w%p({zIuB7N`D%n3!4r53Fk{#>kU` zgBJFEA8zzo)^5<#WJNn3d+XFltWL2~jcwt%{T~*6#CYv2nRfW)S0DBV`1uK0b|H-z z=PZ!njF)XUWF^i#T<+07z0A~G#Vr!7c}NNYZDj)NLU+PnkY^PCsP1e6HTP+m!+s=1 z!fz+0so}<-LN#rUSe_-vTC04fj|l#|Idu73755s6mQ0J!^QZD zMBzu$T~gksfk{Y3jq+%(-;r<2ahlPdAiqc{`GK=z4&Q`o3hJ5?(~*KF@CWVpaRVWS z>2=i^h*`S1wI3mK@>;(nv2r@5l8yez@9lkCqW8-MGH-JBDwOa;AYcA?`d^cN{a`M7`7b8&zHG5Rn(N?Hv*tSUd6Epb9qw>~~md*IQ z8snc(jd`_|LEX;=z;F=$;Q!rfuc*fmX7sMbZ?8`(=Cm(S{6^4b7X4HCQa2`#!NO3R zV@AYGjnO2YXM$CJUH|NCQL5j+l8GTH88Pxzn;GP#k292j+DP@|kAvZ?H2ina0c*ct z;6u*OOj(83bZ#Mj`bG!#0i)Lg|8t$G!OS3Qm8rsHSBI~S)S zAD#RFH+<*#FCh7Hk*%*+C1UMSg=U4*&aVR-1pDAHk9wOZb^e}|V?j4o7m~*l79KV% zNdqE3wM9~ZqfpzY-1m*pS*fEBSF=`&WxD7v#~PIxT5uA*dhp_G+&4W#qPkb@aD-R` zZSESUzd-zUDDw?|EHiSDlRDX;eag!X=*{Va9(d!ElVs9bZ2k_B)*8p9z7x~x@#P;R zrtru2{?wFW9~PPD=~z0vSJnadP_0(*+|UzzA$~nhVr3@j7I|4JVwQO z$T&kSziMVF{^0iY(2;doghPtdhOvOU-dUB_p-SQG#zW%{&D2$X#<~0-T5`wA9Hbzw z%Pe@(57pxEbDSx%ZeFq8A~-$I%?4@SQ~dO_IMK{;Rd*$-VtA#AtZjC=_;Vrr)^01k zK8IPxnNwSDp#TP@~wh*w?9k*w)#rI z*-jMr5Bi>Ef@NE;aj{@s_3C>OF~e{Qcb%!%y?4u%^xemARJ$L15`A-vac+>?={Bnmgf+V@G(tJ=Aa)^KZ2u5qWg!X}pa!9?Si5iJ!E zn|t)?@9aO30w&LgM4S<~*waX?V?{~e{z#gKQpT;RU!=>uxa_j{*2_KHT|cBH2hd91 z%n&G!eM?-1?c8zGTq?vcTn`Xb)wHg+-P&Q~$SBLGD|$=Zo*5M!S;`(kl_(M=eAS27 z9JO~(lG`GtSC zT_rQr3Ya3E#Fkn3*fRT+2bO-Zi7jeYrZje=A2{t`*5?>XdwHDOV2>c?LFi^G4zH#y)6GM z8p$@P5q0V)Uz6e*QttSa(2j2@%3mxO?P{&EORQ*kJ!Pu>~qW|r;AS=yGH0ei8hWc6VNqQkm+WepuJBEI|lXD$NJFI&%6=^-`OZru-&N(iLk zb$H~O>o)#dqffQ+L5$$~kY`);giS(sq+SR@rBKcSP@D|rxpiG$9~ZByejF^&fe(w; z{&^xLlJ!HnVrOYP6mQd123WV+1o!)t<_l!$;#Z$Zh~3kr7;(jO$ZEpfgc|~mFMQKd zbX!dqdo?LP*FBp1H?JdYabZ^aGZ$w`sQHli<3O{%u)76c)q!{c&V`)V-gljT9N(G=&D(zn8bF1I?)X$$}KRr%75f2GwveADGDi+DubC6f+buOANl$va=}#(0n!++>V>IPCY5w$zFcN7aU8=Vu_e=+<2^&zYd}452K5U1>q5 zI8oa_q4#&<0aC@zWRVFC1s#0m1$#=9^-&*3fz{Z$(*-So@DLRk%GV3#ZAgYFQGNmt z>;dt_V%@EOLQoPubr)xRWOaHePC3LVVSU>H7eYRQD@0B?%;tyENEVK{OsHp89i!s( zwzODrwJX`fyI*|rxl#c;8v%Lo^_uH|Kb||_5y{?!)7+KUbRJlap&Ola8pQmswaA+p zX;XDq8n*Ml3&SN=W|=bB3SKpgH89`#Ve(*@Fqjm)wUMCI3y0rn>D7GF?;*z0#HrX3 zS3R-T{p}BdWIXq)=5N6t?`k|rr)(6tzkDw57yjO{SFc#&p39Iw z=BcXZTic>RlWi~eej-Eth2;=Xujx|`z)2e4*nXsCPpT{HBn>pJ_wZS5zC{IozR4*D zW@#C#DHQPSFp@^3D(ua-9MpBibQ$|BjbSZ~rCWVXRrGx*ynKd?!S(PT? znQ!bI_9HF6d9UPUGA|zqwcCA{SnYJTb~N~SxPvny*LIQSUHT}1-q(pyBo?^V<;TaR z=r)gVf0aN^l#M1OZ4BG$c$FW%j@x&hc8Y1!IQ!{5`T!GXTU~U3+#K2o$eWHVGv+jo)VbCI_UVm3jE*vohb!`?^&cTjf>66+L3S%87 zLCEHI!z=IlOG-L_FbCDyaI`#0C~;2aJ7X$kiAuW&n3dS&4ZmZ4G>>7L|2hjLWvwWu z@E~+#>BmM}TI4YPds@3$tws-bN$P>t{-UY2kAwp~<7?*EF<*nUx%Cna)>QkmC$J>$ z=KnxN(v|;cGFqJ*PU4BpKTnNzOxBqv50f`WjO&$Jpc?BJG6*y z?ughn2dTQmSFQxA^>!_pE#G{A#92Q7aO$`agr2r$e(lk&Bh8C19OzaF3^VT`vu_(r z4SP$H446#m`#KGis{lQ@BKfvg<&?Z0=2wkJqfv=*@)UDwgf9R42_ixC645ypGL;VK z+#4)Y(ee(FIn0ioO^Y(f3&pw(_YJZi!)NB&+o|iAD~C!Clm-P$1t|nO9>kLniLK>VaMx{e!8G>4AJ7)Mmiq+) z^s_e&zmZglmIO`HHo^6RuohbrdaWuSrQ;TDP2DFZZpR+YYbmoej>l~3yMS}QqtI_Q zkvksBkUzm!EKz#Vn4c*a2g+uz(Yf?C@FdDB5fzv&Q4Ub8?Ld=)Eid2rJBL?wH0;w# zig2C9J=r3<$$4Q+*#kU;e2&o~Y~mE`&hEu@{Tyx{Ldp)P>*#$W(~A4_wX5o zDnZb|)CCvymnUP7{3&kkA|Fs_zLzNIPX5Ne$=7g-Kpa5}eyZk@XvMLT6#Edp`!Q>% z8(@3wzAD)yB18F5oc_$nj&xXsg5qmTf136ntp*c`!Q{MCJ-YSi4J+5TK;uRCdb>Vc ziSs}=%8yy>`4+c%))e$#M0U&_90;9^?=Z9!44-_mZI4ba0D8?NcZD6PC8+>nd>lZ zk4t-tp8CO!HO@VB^UW}`VizvrtWE8(Es7)<2)VKwMmOJUO42xm`9kZw*60pbMbR%6 z1}~DSmcFv|mgXwZNyf;3V!mOv*}-=B`eNwr(Y&J9N$-x_9mAu9jmC5*^}0zn4xFOf zhPVp3;E>C0z8<9fGZZ=F6`Z0GTqI*JWr<+^40BuSj-{8 zfE~j|y~6W0t082!rqu;`k2@{Z1tpfdDaX?V^@%TNdRYe*AHOBZK4y?Fr)+)3o-v8M z>hBAUNUO-(0>NYzPXke zP4tesq#-7(Jv1Ad5PSB+xSY2>V6sAM00t*S^kIab;_K6Zcz;SIz8kq1B-Eaj4kU=g zU&Hg<%OilCs}Bp#z9w^6bJ4&%Wj%JcO8n{>KiA37yxL~ZkJ$8BH(x*mr>$OYuLU`` zHBr+*<0)d{9VlEz&sbUABsSNdPe=%#PM@m*8dj(*zj_^|W>%e$`$bNFoe^tek1&<2 z9QX($;4}Fn&f+S~eC{nJ{iTCZgUi)(W?MUSYl!?2Zk<$#HzXGDYS!gch%?_j8Rcqa zGr5;LsKg}<8P&MJp%sjJ+rdUG7*&^i?EiLG4ihi_&|rtz1O}>K+JGS1zs-WeN{1d% z3?pec-Q9{eQR(z^Ci%1EIY*BJQI`hn#`wxF(ohmv$~(t74Py+DkY@=6ZH3jGbmGD@ z?UQx!{2JRbZ~Le)A-*j1F%_Kx#TutZ$AeBG1r_fRl{g~~O@t~FzADUv9DF!&M3$4dSU zPk}B+1*b8En!4F`d!7|CQA*acf}YIG<7D7wb<^dWX=`YQNS+1T5A$uAqkJtu9vNkc z3D`m&*w)DCPc;;uR=MlDue6saqpZ>hJHM)Z6-0|`Ye&)CNeM^}zV(>Hl9VUg^(r^$ zcSz!sJ|^>PH%CedOjzr3p@>MA&(of&-pt+5>tz zxL+F3!rg5g`qY^^Ew_SESiSW?qv)yHQt_9`M~C({Iw`BwHAkFSrg6ibib3y!wK0FtBUBz~W z4c{zUi~00DzX>c@$i#|!fW&869i~csdscwu9f+`)9p0cI^(}q)+rHSs z6}P@J%b@!S{lXhZyP#T_>cZLJ+SQTPjl>K2!dbIzqmdClZuT#izYC^zVsAZu*7Ptu zxQO9XF$u9uL7GSbiW%>(f|(AE+`h1@oIr5be?5NYGcrVE(6?$`itY%>1>%vZTiKM) zU@Qkw0L0F2xov@33+4i4r)=>{jMXis>L~B^_MP6)6Y=2es1n23v|FjGiI(k_Etv6Gt0RZ}Udhe=lwV;NY%BDyk!^DPUDf$0+Y}@rdd1rlULsE(x z?j>q0B4D{C=p<7^5}Iuy0AnOG+LzjgkFOhIGg2P=-YjN&HE>Q}wObD3I5?D3(wTDm zjihFUmmNn~i zC^H8*I)5L{b)Fnj*53=rR5gxv>vAV9&{gC>g<3hn|7gK$!ugjWH>)1G2!oGi)8Hh4 zODW&4#aI#XQ)rd#Z50Nm4rFGEtk|*4L2cZe4daAKABLZ^Aq%uJSdz{|-u3*1K;FLl zK+Un@c3TLqqo`T{h&*N!K8D~}}j9Aq4cE3q%T020UBh?AOhZZo&~;d9OzP0~NE z0oSUW#?oWY5a&zmuF+zlhs_T%p^czVe4uyhc&me%)Q#-Mx)%E;+}w@kV4IIN;_ap< z{eI!D(zl8xM-W^ z^>2YAU06~|Qy(4>IZLw=baz;JzZ+#MN4sH$k!h?ZwQQz(w*Yj;a<|kAmkn|%BZ7-E;(g27MM&OV3dpnSn$->G^Q8ezK*sO@?GVtN<^|QItH@OyUYp^9 zlVG$ZeJw!J*l#Ny66MpE1S9K+hhQVdLQV%@SKTLIaOkFr))Utu0FpdXcb>D6^*&y6UJ6Kk9*9;F3&{;fs8^5X}JtVEP7y3=UJL( z-+=HZ4GJua!f$Q8;=Us$Aj|=QY>WV$kd-c+P{bGcue6t1gDHuH45HiN2j*^J6M9Vp zRiS3NBre&p!6{sy^PvBm1v1h`Zb;i+&gI`81s<%AaX(${qF(~73fRX!4FipvNkd&9 zBXWc1R1z?h&HFjk3)^rP{n`b`h?@6xM#!a-YI^7j#?}@~I@4Ku;o{y~(m-V#}ddEmBed+ApI`+b=C@x9BHkq5+V^o;$|)+S^}%ZcR5b zK+VLQ6yq&K87AhTDq%zvz}HMUag|2C4AxX~}Ln7Fcl3?qm&!~pgf#c`aq!qb2! z4NQ1~CW)PEqDm^y;yA6|S<(2HQx$G{Nq%8E$d`-2Y3%%68?UT8?-c_LTo|3u2`Cf` zYkLic;}q;(tr$pH)xmQov89jywzibB+E4_|Y~vkGNu1z{-#(@k<}xEha?cn(-|ioB z%rEz9Ip|`cpeUNpJbSO56j6Z!!w<7j$nth$E?eM}#U6#TfJuVYgQi_w6m;v=8Mc|G zUy{%^<8zk=7ix87SwiCt@ z?^P8-bx39j06;-~-Bflq#qULZSKJj9Wq^@9 zfEnp)IGd^s$WBfog%MqBwf&$l5T>iK4&u;`1Q7(9XN+K?33M)4SxMPb)mx!Ukq+D& zfT8UVdv1~(AuN0zgdv#jYPMQE_MQy^po9k{Y!qR_7vyvuUS(o;t%vyXsQ@lx4EVCV z%_(J5-Sn>D5pZ&=;ZHc@Xp1zEr@$JR+xM|-bQ#9aB>{MBu>sR9;frE>;^G_)4-V_V z(Z0J4wCu8+o3wz3<^@#K$bigfDlTOOSmwOg1U_MANOJy?hgp50$>Eo8(1R8fW^8-P8{xBM** z9J^KVmUERgMabt_qe6HE8I>qPQ(f63??zw?ensc!Xt2?mx&5jDS{w}{B+r>-&^AD@ zN$nJp;{oY-@#(Mer6YzR^cNq)=tgJ2SiApjEovA6M2O9j-z zl`HN{B-xA#WhFv#(5CfWBg>gt;6c-yzFIbY1Tf-656*@8{1I}(#wU(z=nOPzdx2c& z?Fv>FU-*O@3TS%GO!d)c{ft3CL;wPq(C3_k{AybEpc@69A`j3V1ucNs5flAdcF)~b z+l(I|OOM?4lvgGl^p`!-=e7dVDxkjGV3Rb(Msctv=|v@YBbXOiQ)&Q9-UVmJ1n5cw zz}9K}Krf(gbM+jmQ>Y(Z+?jQR#Q@!XEi+i_}>JWG>QQH6|5@OqI!+grkld=wt*QQ4z5Rv z$|W{ICxuB-{Xmn$d>2fM1OpHONn$fgd8d;|@mg?{30Kh2$*c$4Q2(~VNQB@T2;bu{ z*knhLbaxu~QWJ7L32T|bk?n}9GZr=539yThGW#KrVVgDU!$W5F{J@+|G;}RIlm9|@ zcUiH%nB5Bm(s&kR(WHpfc<^Z;)iU>6%@qUG+W^c2D9(69osh7197#9vIu;y3u8S?_ zQ<51SdVxlJFJY@5m?;mGIu!MXLA%@m0w7s~o?s~~J?%^Zd|N>ZAf;84*dicGG`QI* zyWEDf*1R|mQB4TbDy0MD?XhRE_(4=KfMO-(V0%L#f~Z9|PutW^2{W0qg0uwUR1Qou zY=IWLnuR%5PI=m@qeDSPIrY>#1dSy$0$bP4Vw#S~jAm9~I8ez=Ey@(T`ci7I0=?(+ z&}HqC+h8iO-$R5;~m)oNdFuAn~Hf;pL z#3hkClyq}}?wOL0BvJ`R4SB&8i&Z`P%~q2jmjH=K-YpGGV@_{GG|GzYbRMu6CPt)c z7^o)0=z)~lSL-()0V-%KkUTUeUtfi&iUWnUpmk4UT)LdN5IpJciAiPBYM_e7hh&tY^>P**K>{A{9 zrB-W=txWhfX))L{vMY;Z5IY6%O=;PnvqLf`NL-!Byp+VK-Zd~K)I3l(eL^C` z@07{`u>`V3CD1G~_MWHBw<)pXL773SU(JCRgTzt=b~1{gP*JvA=kQ>h#ZkHIT(`93B=;{Ac%wBi zz@R}~(`p=JMD6TnY8J-DaX1eB+y$JC4>8iZ80gqR0V!?T>+yM6{ZezKX0+rgA59Z#?L9~*R-rvtV7U?!|3VUa9G9-3!Ek-ex^Cx#F7t=$m;Q(VILA}>N} zB3P7CrSzxv2PILJmV>74!ApyaoQ4fgg{eT|O1N2Kz<)51q<4mq`!}Bc_!C6WWi~F( z+rWq*r)KQPFTBa3QB$X0UcxpmqN73#NZKM;BzRCi0d%DX2?mqcY9BN5@Ce&e6#;0# zPrI^${*SP!|Jc`azgy2!MkJzpI7&GWWecKhOPd9JY>rS+Fd2ARr^WB&s_3TElr_TK z-28BJ()D0$ zt6R7q_nMzC^=Wznb^q7m=wqiXNhr1f;=xsvQc-#OX(27AHS~9f85}PpeDBM--@)__ zzg9DkQZ3YPL+&GBEYRazH`*378?OY3`{o$vNIpbf*a*P|}pulZb6F4f`*| z9U(a}n1{G?GAI~FC9lqK8*<|*L_ zOwF_d_-lVm+gRMB^&OS6kZA~m$0vuCZdSNrKTMTC4e>zvV^_PthxiD)nc-Yv0b+}v zUuF`a$LNqDB6Q~?Q<0IO%ljVSx00v3skSAd1f#2KF9-1JQtv}~3s zBw(%s!YjFH4pWwJ|IC~Mb;Ljf9p8MuLLz7V!LWiS@W|B|84iJlMocz8M2d2MDakm> z;a)?R_|dN{huMY)vQZJNIS#`9(vNk@emA1<+bNbACzF46yyigP_=lm zKY0R>AzzrEEgln}zFg@`8ENv~KekZcCdgWAxWAl6)s+n@Sex7a$Vk+ zFO}!k%sgi@|2=ftzSi&{O%UbB=U;P)isgI9jB&t;`B~ajwXLiq;|Xzd_L5Hg(rK4- z->}G%i%6KhwVw47PvvM24TsX7Nd_Ffk9%{T^7S+8SM~R}aBx&Br`(_a|c{lImpiT&<(= zQW=N@0a{~iBZKjcLkfCjvySym?OOrjn|;CYJp`y*w1yS`(y z=AD4UG3}nO*#hSwRIJK3LqJgIBLkZ2on&^fk^lz%y4d<^EMsx7E8`jg5^QmRfT$JZ7E0 z419{%F}c}$rORQI8n0i+9^a9PX53m`&C@DuZ)?l0{d*+V-@elEb-$;3>fAY%nu0)(iATaPMavLu{HL7ekwu-xh3q9 zt(0K63?<@gh3qCPmH;e|)HyH2$H!l!xUC46z#mOJ()w#_Ydb63*=^d_&RV$c2CeYl zjug_^4&ReM8zY01__rLaXHITbWB)TUuB8d;YMb!#YDEVa- zR@@P+%=5UZ0_G=tzKG;63B`sLU5vt{>i}QX%q9!Qcr8}{e$GVmow-}rus2*@wfc5) z4es-u(RWWFs`a906UNYDA3a6Ih+$6;4=oW750CjW6}Uu?X+JiLd<3CF8?rT3t$wvs z9O8s&#)h>657rjm9Lfq&N;vlp&?k1dPNhYEhW9ev&3 zqY+ObcNH_lCYR@pj{I>)fE}LUu_*Qg`2$wPK>MS9t7iJPfZgiK3c{dp z88^h?-~=)G@%dg)?tVl>M1PtfN7?`f86;3SU4*UQdw)5!-FhUKEd(64w(_Tlh^D1P zeW?{J3aX-{v^7?k~b!dxLAs#G_Dc~3_6M388dN|t{8Swr+Q4+1Xk6)!8tLZiN zh1`{pFgnxqoOPcdF_bx93O&2a-&^BxKoyer?h#I? zFPQWzbLnEdiJ#g=x?TQd)OR+#FCX|bGS%WbJohtiEcThSA-HGx+?4H&JjzeOX<6+r z_uKv|L$8k&rl+U-`}y5}@L+#$Z!wN^eex6gP?ooSh`Cu5r$`+8-*p%`D3TNTqc520) z!&}B%EdHP~Nocb?E8EDIlOaTse!>CJVUq2WB<)XV@F3MfB_%yBNLqfRQe5PU_zKM< zGQp^GkkN1eXtiotGPdJI&K@2|ySt$g5q-VAaVn$?Vse%D=#JXtlr(Ym(ck<04&IY? zx&KB?iE zlT*6_Z=W&mjvSXDP!|8W9sgUVFyLBTKOHPgUxdNvIsh}cKzXWKT9~FpeFgHxXw?mH z^%fkcFhD7gm6oRe>eVY3mx_NGbYCqoj_IeP&(3GzsrlC=1b89_l4~zwV*M(#tgmoC zZ{~*=NGqCPJpul6Y=hjf|2ahsBb_@uzBvWe{+SEP!hDI~OvIUPf$!rc6YK>*)Y)m# z5k`IPopUpYo=AGZ3;>y#(&35R#x2eZGRDTnCl5*XviLrT@^5{bBx^jqwe(mPymPS= z>=@m%clrF5MHqYU8gz>xUIn79~%w2C?G&(FXCrAQk~yl{5Ne--Gc_4FS~oeSx%JEduyl9+{b>l z>A8T(IpqK>c7PZ)^meKH-?72Y{&eyL*TuEB`BZES`wm7I(_*kOv68-Op0@bKLrh%U z-p)>|#DMOvTS;&@{J4$E`2C)OJL%#lu8a$kb8`V@D6ItW-@id_T>%ZV4tdHe+SN7D z`U~u2@2IH;{~E-}-bB15{ZxhYU}qo5|1dL6AtGj5Uy~;_5V7&A&G_S{rRM6Pi>fGX z0QVcS2mg<-w}7fD>e_`5qN1W828g17NJvXahbSW5ogyLKAdP{fgfx=U-JMd>NJ}fy zDcx}AMtHyX`~NZSUBfXP;5mD*wPro@nR6|4n zTQW099T^`@cg3-{3bEJ(G>T~rs+SCB> zyQiBRY_T2)hV$9L1^HGF4*Xu&@1}K4MFzTZ1e!5hy!I)gm#{)?dTU`KRJPsxc)iG{Zaoou<_*uxWmmw0ALq`1#tjHVQl49Iop2JB zZEP25yxh36H?|*9RDb+flmtX>h%p=Bt7(W-+UJy8J=+dD#F^KRCSa+^p!ZpLDhW7Q zx_lEc3f>HWRiQ=QN77|QR*jc9h%sDxId)g*4jq$bnY2&hm_|@8)-yY+dpFsg%oL5^ zM)Vf#|I9O{Sp>&65t9iIIDYW$m4IT{TbXDH1g9n=JHv=uU>PUy{pGo&%ZJL3suvy@ zuWl|dsepZ-%1l5#ldJM|B&@P)bHrTd%sPAI7-PUI=TSLCZrKp8BL1F1GKv z9?zHtRuY;Pw5uxn>#{t+yLj%wk<_72BBOe{3%yph&>G*~2XO?|qAy|B8QDb# zDkU+`z+o>0MY!~K2fuc(7vcF6bQO4c&5BF6!POwc z#m;P$PDI-v1eEZ2!UQm3wuf{SSTj7Y#%6r2!Wr1mB_wg!jXMunctVhB7z{ZwZC!UT zp8&lK^ZEc*Tl~pKD7m!QscY%MkM)>Za~;iQbIjo(cCC-ko8JOHsq#R<^$NuFNK{yKMU%O`ZX`<055<=2R?2VltX zh#EU_w&S>qtR|7jaP>29Sy*YV`LSuB!3qN89B4Ctp zb-gF)S#*2es+Q6n*c6t+zA|u|wm{iKi5KtClvzXt)I8&I*YJ*yB=yY=Ww* zM@m%WM*+H_2k>aYjf=8l9Pvyf0*KPUppH^=9{*A`Jj5EmaM_;(4tBN54h&8{Z)kZd zdFmx_z$+cCNt1A^5F;|{uLTeP)w5mY=K zrrIu|yuHWsv19wm(rru-4>Gy|N-Q7D+>snJ@q=Hv7yz3^&(ANY7q#W%iMByN*y@(3??l z0K{unB|#WA7#jMkao1%t7Q4^XAfe(HB?KW6VKbqR^3#%%Jgm)VE|lPwJffYvK6jn! zf_YFx$E6t-$1SgATtER~Y%j3c7tF?}N~Jy#+`>88gzJI0S2OjE)J-V`5qV@H$;5}i zh>k&k=;T$ZbQq{qiWVy1dZ-oeQlFSv@O=5v6NEFOQ_{^`c2DjHg1}TKFKd{E_GAwd zA0FBS$%k}?FE|{l*hhG(OkkoeLK9q9KY9pyV52b}f|2A%ZUasU26d1c;m#!C(&G8Z zEglMiDUwdJ=}hvmYg_zS-d_Jc;?m?9TEP%AX6aZWhs>4sJM7CffN_x1*f?~ugBp}P z=tpH?2n6Hdww!#2v`cI999t`3GJQe)#E39#Baeo-+8^E(0u$9Uu!+bBrLGXe<9zd& z&f@~?0K6^cP*0c%Vh(?+8ZuS+&*3ThM$!1U;fLc9OtB{s_}wv!AZ#z7q-tAzJy+CT zpf#jy0}>)+xICnyqu6v>{}dY3j_82IIp_uA>JBk@@78+pOZhV_l+1O`nc6?mSwSam zF_^+Q;|nB_9un4OD*u4egc4zxD0LuU21mG>74P?m9hfG>C2-v8(y_iRyLj zC7w(Gw!rxyHsA$YGS~e(tmU0s>&vH%rmFn9QX@)(lLF)?z|ckeA#2bCSWWC7JOjwf zTQ3LU-2m9t$`M9{fuy3ya8Z0QJh9kmrl4n6h`25=>WLoNp>>#`Ky*@iOa1I5^l>)pz6{f2I1}tX1i&=>4hAm#_Q21(@p;f||${CT=A9 zoa|?-t6CCfZuCvaSCJW}fi6j4U%P9w^k#xtR40=FmHeDj8YqeOe;b25RTxQSw0I1_ zo`Mr~Tf*2lR(g;4zSDdz+weSDH-4wqG!Q&a)?dIqLl0g9XsBURls(syeZq`LDtMI7 zKg_(u91fC(&moUQW#1_I{)dzB7S77=OQ6>6t%`tXz@Gr3F_*|X)z6R!_ggD#R-;X4 zkC*Qa)|3qX7_j_!LF?Pw0N%jiN4OrWp16~)0i#1etk1qjnrj@2IhAo+?rWAPkDWd) z5?m9gqU~aUs<^@giivF(`6B;_#r|AN@D3-|ilciw#-Mh6k+7~Pv_>s(_pn0!8AR#Q=0v|Ba3JuYjOHG#5toWpEzuY-tD;?j_{M zh?&qGm;(9e_XvM<=~KVSFjK&OG@Tf+zhrW3lc2RRJ`gp4!|+hdQN%*2NCPA(!bL|M z?}MH4C5}BpT$dO}3gxnyp@(;d#0ge(NM|;>J-t6b0xxb@&I-dFs0mHzK>{ zpQ`Om{OU28l8>kbzOTa$LtF!Q4mM@QYn zwx!|gQwvZS0R{?8=TR=uF!VbMW}!Spx9Ktnq()ao##37-e`LpDga!@2GP}1`aSiAt z0tI%n?*Mon9~|A*{`b!sFKfn*%mCp}(t-nf4ezm<0)vF4Rk`f}}Fj`at>W)8vs%Dto09G+VC0A_;^j{c$Eujp7b=mn3V+m%= z`AgTON0cs8h!uAAH~h1Ysmuq=-9^(M;xL_3e#}p{>ffj%O;Nhi1F2N?gOdy=TLv&J zxPS2Ih-%`xfojTW%CXt=JnjouAI41n1SU?9^kfj`x+O3}Lrv9`&hJ_0t?nxAwQ|a|Ov1#(K15usnsXoFFGr z=Ft-1#)lYW5Ur8n!h8XcUm)_0U`RQCeXKvsuiwkbK{Nv;!3gUHf71nWJpMGm<)C=& zy-g>i?7HfFJE+}o^Ga?ssg3BJ6Gv$vp(e2~p!cTP$MJZEK*v;n5k7F z#t7_8Qjm2|A-F9upY%3RA#u)@fiTC!{yA&TRVBoApFVQ>06W!i@v{p0MD<+c$Q&Ni zU-S}#)l*UX<_@3P;CkQvo&@n`p={vI!Y|oRfAQ<*@h?LeKZ8&JX=(GxngcAYTWDp| z-tLF*du~>g(jQ{m{MWOBEK-TG+T&nC$jhfdP%+Q1vDn&M;j5}i0Hn|tNqV?eyc~p3 zga2k%yb`T{H|F**+)uIT#|qq;NotP!+F~4fiL}Eq*YuAr98l zq-s%p`~e7nq{hR)0WVgnAiP&KC%6rj@82E@Bh>BiIn(#!{UzrRB=+y)iO-Z(ZgXmh z`5mOM)@ZWTl7br$UULFs!(0RFR4PdT9mp$pgb|Oj242jR2Jm=!sW&a%uOdg@42YFL zMQbf^9WyTQT(YMDLDPV@eyn)ea+MnhLwwj;&?+$?`_BWvGNu5f2R{6G*~GByv}Rv6 zlFF4fHaj6K)Nl-dTPS*voxn+v=aN!`J_2eS3|mQ;fHyTQf#MG&5^77~7f(!Dj>>xD z@naKkWV+7R|9wWS9b#n)i= zq023aCkQfI$u6=TobZP$9LGusM-yDAI9NA^{2oPv=CRO10ESw^X&BIJ{AnWtL4BOe zgsnPgLV!GV8K2sw4dcX+srCF4nPo_#Q01Y><8oc!eauYH#7PnXa zgypLie9wXcgR}T`6lsCE?x6APAAElJ7JZZlx?@gaLb8C}0p!sR z_Xy>~qi6(*quzH{dVx0Cv|Tz8yhRUm5@BGtO-xKchePG|xYu}Y*YaqE{d`}>*5Xi7 zuYUb+iw-Up^NGg%{QTnLVkmF{@o|}udw6v8aDBGh*4EZys&%$APGG628?2?2tE*tH z7opuWP^fJIV26N3(0LsXUgDwROL9*3%e_#n_!o|Nxqw=Zy=l zWjd}W;cCFc*B6hcmF&R-3b*gRgm`YSO*io{P?d+f1_^|Cc;vf!dPn8IW1%p`fbt6r zd_envoSe!rQmj8;ulrR^lEJ;#qp7QNpoQKb50&_SjKMZ(6q?T7zI|IXYGFgz2ild^%XFl6j*rZ zZ7^9(z;n64tlQCyRh_YlgZy0C3+*J}gL+920=0my9+k7)>sqe*TU6L`xWuN;p~S%W z#7TwToxF=`k6?=<5L!lML&-6Lt^(bqs;a839t~wyuWVdG%E%}^E5GsLI|jG@R$!%y zazWTl>#uXfV2Mw_5^sW!DJ#gQauQa7!XI^pt3SE+6jy2RLS^7n!@O4!MCobx9-Cui+Al&CN~Ga3))5HMMob&>xR`_&nz^tIzT(6 zET!yZZ@*&|9~AAw{iSV5p!6Vbiw|NWgN}hkXjRi&{%dQF$4djzSo_@VOP~`L&GW-al3ictD3TlB0Na0X)uYv7#eu$d4q2FC!5A8Qp z6%80Hz=gGS&09ucdpDl69>7-{WG%^h=fC-rS4|qt&sRf!!>6|QY$+UK)A8^NoSaC5 zG?BpLW{8FFcebH*TCu}vr0(RRrwIwSu)|uaF%MHOxeP$58n&%p5TZ}n5brc1+9u#u z0HwE}84E!l)_7lWvnnHm(&N!vpJBDO%pt16S_VzGqRUV;TZR3o4g}MhzX|@)O_w&H z45hCNMWuGuy;Jx@0{N@N7$YlG83=yqAX&3Lr`Z3@_=ka&U?$qdJJx~Icn95`vkrFN z9A(=5Ij&XgL+g;Js5`+?K@Fu_D3>51Q2xC6d7$Be8FPiq!fG#e*F57S9lIsm-YLCg zboUy|k{|joHSlME5P*}!YQ1`*t`xvDl#Y%#clZr7Kj5`9{UG2L3#qbo;q2YLZn+&p zcn{?3F3gl7A_)0^oaq-_hXP+u*QZmcqyU|F$x2s51}l}ZBrt(lK;P}~E1Nn#P6E3` zISE-vrEWHCPe#$kMS{PFndIa~We198x472?c4SUo(c3w12{p)1yWfz+KnzIX`H_Pb z^VL&?M}d_0;4PcOR2a#Tph-BSHf`5WmLUT~%K+ng98J-tS>bHOL1yK6Tr$_w>BedB zng}w!1$PUQjpXa&FU^; zvKK^Zn*Z6EOp4_?y{*Fcg-i~E1BpeY2Uh_$qY{AuQoyN@D*_S~JRv|c{YCFQ6CmVH zH~cTuIHA%Bsoo^YiWth7P;4;oH#|u*t9zlkyLtKGbxVeL+3?1@h|?`-Y$BaM*b_^G z{1ghhi%u&edCCW;VCZea?gxPP(D34q-s8VLCJX6qi)vo|KRu73Cg-6ciYQeA=Dj3i zB@c1|Szn5|+p@vRL_7ni9;!Z$7N{|3(3tyvFBu)FBBF(au15(&&1m#>dggSSVAad0YRZ}BW+){f zMNW9At2?$lVDq$-AVnW~cABO)oYIKOYK3$nXjXQw*=dq%Aees{iV54yh~gjf;3tn~pTekwnW z&%FzWET5sl2C^K;DPH|se)Y!}o~c8S>6V8a-Gd%b92}fGcfLTYT1W^v&lc(y-h8As za4^}Xb{XwOTgs29B0-LKSL}6Gfk`^e$Zx@u6QQAN@3}KzSx9q^$Kz*GG9$qZsBEhh zh61I<u_}lVC zZ%@&c7_^^++ic=4(}do8o`X4^x~mI|BOgtSdXH)n|MnfI65h?R9~98tk617LJ0~AY z9TSM=@`;en%-r1E!eVU;%6aZD#KeN5?NQ!d8%un%HT7p61QX}n@*th9sp(0rQi!jU zBE_Z7F>IRtA`a>;9874@u)#xz_itMtIP7*c)>oYpqv+7(QM=?!f(e`==-L08A+Oc& zV#gwORc=DdkBshV?>A#%h`+^EOJ%%wU-huqYM@Pw!yKD z$cTs@eJkjj;^TX_Ka8%Sl5V5fi6iW*;F4KRZ-q}8Oq26Qw(6_m4G@b0Bp=HIO$bwq z=E5$ermz6M!K)+T6xgXsTOaA(<$Q=i{~#zM()C~(`#-|zvkeNlyBfvRQc^KeI4KOL zRe^9oU@spFG7crH>7p1a=jz&33xFW{ewldM#wZC?IDb&{scDdkS9fl$?< zdjZPbB?eO`GF4dn_~L0`A+^dzS8+y1O5mm1llGs;zyWt7tIJ(rR#Xn(T+Y!s*e=k&m)=MJ08V0L&yd z>GyNw)VaG(eZ(cp@$;BW-xUor@3lk`k&~07=n0L*#s5ZZdkklA!0D6KfV0^QKvhE^ zTvr;^`uCb!KWwY$!4(}dy0u;hdM&XwRUu_Mv?pbbY&*F!;;ySV=U0j>>^VXlSB0tR zcI@@C@a$NOM)Ow|KM^kU?F6Xfs#@1n8Vzw=7TFk)IXFKbKh=uQ;(S;)=h(~(en2BU z-J;^UmzRR3vF6KbEnx~hsbeusa-tZhz@zIJtu@_`ZRql5t_EiSN0PqFq47I*_j_gb)}nDbh~=hPbT7#}n;$;Bm~pQ+yVSa( z>dE`_D=YVcBDoz)y~G#({%-3Puhbm*iK=c6qN1xnv1@#_PO~wrD2wh$<(Z6GVlwD6 zT%Bk_WI_f=1Sp&G>q#duKE_9DfdjhvgfTCKpx+X%7G8#+1ZWGd`k!Vfa2X6=)eB|+ zGo7E%a#as~a?Czrsd!C&JZV{OD_<@5d zw%E@-)=~}EJNK{1pe?tLJa){?w>O{DU4BTHxxdm8E&G^fUyWNdaDHzMt3yrUK!++V z`L*-fl<491D@pC7Z2EYs`J;5jwUpxF)L!Sxqr>-^s>??m&fy-ljg5;H_D4l}-5iUH z(fBOJ5)ei7=Q2Cv)S=~BXK|=VtCHSJ+@S&mg5jaW7Z;v^(sWRBn& z{D4+l(=kUQE4(oajnVRp>W<76ki>X;^?&7;uFvq8>PaD~zt#l7v)T6OeQMvPHroz# zxz%k^jL&9U&UVGb#JIb=fB5jByqt6ALG{-~=RbKrdxuT{46kY<_l*R7W_s=K+-xp5 z2$xZnW^$aW`lwqU>rcAr)A+YS8#C^UJ_hk40d!a9>73S$9qj)s;w<%U$;r`}sV9lbYe2LSxYvUURTr`pX8Md(!wy`=OgkfGP3V5Dd$#uC>Ev|yp zM!hC-se8*+y4{JSW@h(_MhEGctwOqPP_?}Bwes-YVs#vpR@q){*@7!u1~(2fltVTb z_v$iL4eBWSG9woU@;HK^B224>fo-hcoyafZO-WAvW^quwqQd!65}He5?aOKOc7_Q_BN+ z0?9%+^_1H2=JAfSuw6@oZi{rRVDww^P`u~nYG_hj)4f!+aQuNDIw~;En8Ci(F>4-j zy{(Ds9UC`z?20OjtTsLct#S+VkQY71D_m92P*DvTv7NpvWzqRHg|7UEG_toochiD& zUeA2Qr3r`amBPZfVkd@=a(6d19xWHtcHWpfcb)9AKeCy(P%+8jA*&86YKQg^n4dlS z@Fo!$jyp3qlQaH4Bnb{uq7~89OLNMTrDEOg;8=Pc5nUy(vNW*fpSnzw=eXzFtexY; zwfZ8-U<>vS&UKErvE1#MleM-M_ex|ynbz0OH~Q0Tjr2bzos70cm%NPX>FG(4p4XNx zV@u6Kb3uxh=AooES6)@SpwTGh!x1Z~wBB*TanQ`JE-BDVzWSrgK^FbDr!-1IdGcAP zpa>4xw4iy@n*H%P=ESEuZa57bBgw0{bZXR2yw?e{-Y9aHi7Ed6_yRr1B95EZZ5Y(l zxBpFaLh({xLkBpr=1Z4$quZFr(0YO|Jf~{qlvy#C)-m0VN@k-O;zXba)VLX?>{XtcUug@72G% zq0W7@|HpCH@(9%R66RC=-I32152IPpQDkXq=TX2Gt1d68BQ(XwmFZ}_(U)^xbd{#3 z{q{^hF5_yv+mDKjSjZ7LseSc`J=tf2%FuD<+Jkf@dLSGXvoqOt%W*BsgXXuWJuW1O2oSNErY3gG-dDt^b%E7Vp0afSyoa9_-g9$HW zekOSf1}n(vm(UwkO>v;yT~omC8qwn6nEl479Hcr>&&axra>ooHt1#ahX%iCS+Xy+2 z$}D{IFetjpW}?vv6Sv$7E(3rwH5+ria5|zGP9P5!8gbYx4S)T5zq4Pz08SYn06#jM zEExx9@z&vxHU&lUs*-A{B~B3|P?Svp8b-%BRa}v`Y!Lh6HRX72X+4;KeH$1=YH*(x)5;79t z(D(_A$0}6`JUire_O77? zY|fbVG=`d2Z=RB?Z!G~~x<6tww)i9V{dW3!EP~L$!1#DL>uyrM(hzAg`fw@bjYd78 zuCz9acew2)m7KfsRcFmFkBvTJ-L+fz`G_>NeA0kNLe@mx;jn9w%6VgcX_m0UP`ZB7 zdE;jPUU$}tw#DMSj*iY_!=I*bF3ZQqN56obn!1&jQNbkzx~1avjk4(aPnrODX>LSv zEdv+6&(6Ze%QbM+pzGnoF`2oOb_fcmllm_K{z~Bqe;CG;SPgvkMWb@!6~_=`{r-xi zh$GYAT3l>rT~!-nu%6<1ttwL1(+&-luW zyNvqxIr;eHJ2aC!xi7!5jPH!YX;rzjr+j>nX-*)jTAbwF1gcs$Zr%-OzNfBB4p4;w z1ScBh!?OH!UhV10kmztO`}D){=GE;#*pb|eVMsWnR^t?9`>lTf?0hO@PAX~??Es(4B&89EA1lf{}V zSdrUkYJN3u+1pyia~rq74Iy;+`^0RZyIWet_(#m!e0vTS7O5N9q?3t9QDec|qNAdg=I5!FTEI%2W_}QpW;CH&Ee_#1Z#Wt$?RRYQSIEgr8eKms zI9fMw7*N?Nb=+Oo>(7kbR=yrBB_ZLrO|D>@j%q=U2;t<(pU{IYN)&=^>vpDEtwOqN zyaxjt>qAJBxaykxLC9THYv3w}A)Bbm>lcQW@$; z+C|3LO!}6};18XqBY)%LqY0@G*3r>!&Gi=i2Qm5qaZSl=)&IqW{pa8)&D>&^LOR-w2hQ2Ee+h>?j?2HoR+V`foO!kxFhv4G|Af| z1W~yAT+RlS^d9`82qr4bU08^U;;`ZCZ7($9ac53QUx?Y>Zew9AwJgc9T_e*hkW%Xe zJXT+#c?9h6E)|U$KmQ&ctwWj7P;guL2(!bs*H;VZ9!e66)Cb|u?C;KJ$%=b-ycU3UXPNMZ#Y%)kjxS*$P225^4YYO-FtLTxPj?=Dt zav2LtPRdNcF!eIF%GTS`%|*;er9#D5-GA0{q=RZxoj3Xqj{Vxme5O)?5P=gYDg5Wh zU=#lS{!n!iI(v&xNT?a^$p~lCTm4&$4O*+@u=6lL7*6pH6&Qq=i@`zbndylM_m*?# z&N1q?8;(_0yczeRA|oTCoF1Op3F(}N^KnQm7ioNfF`VAz9f8zfOSCEoV$@2C%qWC} z0?LqZfhGnUi%5g)f(NhCPp~bFqEW%-`_(o4HB6)1BCVxM9KPp#2 z-%hHfyg?@k%!85rW}7PdnC5wxRMBJgaY^!?{ii-Wwg%;(K8uNXiD{pLRWsE0QfF<1 zyN*0K*w`Lozs>!B9Dp~hI{d#KfWO{>5BGcR?~KQJd9~zqa8uE?MzBeX+_n{*#~I&U0(AGLMi|72tqabMN*>$_xk)f?yRoj1u9 zB(?gND6M6(vkg>-RjKa(%;v#7BlYodBV~+~jKok``d?0ZN=#PINk;o*R$62TJXX;!0V)h)QE#587MaS@J`ZaX-cn=>qOT%!oI zWY%iD%E3`KJUr}%P5AjG{V?D-@hHPruhyVeyT9+i+GM{zLwq&Ri8L9)vY5N z=j@ZKXP?~gnI1~bfgwMw7cPSFn^3i&O@>`#arHnH@sl$(QNO$uF(!_6K!0lUefaAuE zZ;GhtwhWTf#fLPbP#hc_q&X@^ugU3$po)496ZiG&*PPCWDvF8&ot=`>($^P=iHU!q zi@p#Q6-`-)T#Dv)e5aU8HzB&;iiR3K%%6Ki`sI~^*|g9i7TfK7ICttJ^5wDUY)j5p zYjQ5GNa}=?Vf1>{!}<85dy=y$3GtLG>gr2}p?G6&Jl|NsfBcTvP+q^kRzyYXJuos!90#&d!d1!otS>Z6gzMh<1@U>}_%ZCqV^{s>)xT`K527VxouJukI<2khVL!H>rzrSRx z9#HJw;Lx{SeP;yXVvmVPzGD^_(w%XMm;mL%_t1N8n$hssjIQ#ZS!z$7$&88NRaD&h zUF)XR*VOcojcw=KdyEHke27Jr#%HSFJ+_pqAB(+b=SIl2TLuOb%1>N%u1h0rocu-6X7h~cSy6AJJ|>C3(N(ttg|K=m~A3n0T}@l){~rP6umSAze^;MF~E8 zB4ekfb}zymPL^v#bJ)=SwBK4ffE#X-lPQ>)nPp{rL7x5vlu^F4sS_v{xLk%Jh}8Az z1mHNf&lN&fP*;OKT_6GE-Xr$a+Sl7bH*PgFnv++RUB&dcx% zZj3_fE-fwXxl>$n(9&jr*EDfUZn#9MjD#D-yFOXJlYJ@u76E~XT>N?A)@U9=9k60) zX=!4$D!8`6^ClG*;o)A~=uI{W!%3c>gjYGb{P)y5DmLcQsdgEZUiGCbf>kbn|zpM&m=VON;i9y;&eN6k9hvK z)4U{Wdyxk-bFlP*Q<)^i)gK|Tb1wJpT@+L+jx?6N@QBd*>don!6Ag*?FWjf`9IK2g zU`U}Vs^qSHel@;*b;m-eAxk$7H*?DB3&CrqOPP{y8{+s%#Y=Lv770W4CzyCHKe-zJ z9Ovi^FH|!!GczS99^{$+vEEsogf^Cih1<3Q#ODLL_$5By=4pS+<6v#7xnm;bTa15g zZF%`x14p$|>({Gn{5lugqzubT%+P+T8iggz=(FH`<`)zcRsA%J`%|yRYc=(e$7q{J~W@P$(KF>CdyJ(DtGSUqR?=tn274SFP2-a(h(<#)7~ z*%?aaLsLPFL{}GviaLORk(TbRtJ4C!1J^ca9DzOo5!Tw)*4x`l%y5UzTuViTpg^vE zt&`uI+H?sG<$I6ooe{I)&uqA$rzM!?4qWNe)sK!MARuUDey3HrySw{Y5o!v}(-Tbr zMuYip!<7}Pdv)o|i17brsaF-|FBbymd64TK)bHBEca$wyzYLq zgRcnx0n<{3ysqlk&BdWw=jQ)*{>jNNhS6L<2g5})S|%n(tCPa4CU65t+PXHX8i*=# z@umH$r~k#m;?nQl8$}E0nfO<8$B1e(%nC`RUbXO6A_d37~&zqsQuJ zygK$HfOAa{Et2d!d+A>X?6t3s@0|bCs)wEz=AHJ4#VvGJVQo>t0S$Coi|}09Tpr_j z^H)RPdbTUUft%;iqeoO!UJOE#w?u^QJ`tQVO0s%s^gU{9Sxh{ApRZBXX+OsiXR+aJ z(lDvw{ozLHSVhlIEJhn2*V6jB+q)R$5ArSZg8~D+m2R7CS#yN6T8!pAFN=M==742x zSyH%|jA;(Ux3d1$)mr3MKV>Vd3??jtbE)xSN}C zP50rDWYCC!KAsQ3Kzve?#rOvUF);|H}Su(}>SNkUh} zw&ZP<6LB%dWT#_WL^KlRno8rJLvUx^ZohEUt5RfY7cM`Mm6e6wpc$yY-n! zJ7@c|2zRPqB7H4XykdXH_@?}-Rl)JM(F*=SUEgr0wvBvuA^U1wv#0fEUm1nzmHW}2EP09 zB`;&qRG+FP*zwN<6FQl>x#q&60E=MD5teCc-|qr{As!qT*P&17_$H!GSP3i6G)m?A7G zBzc?nKkEnhOUHD-&BS0Qn)w*R_>T4>JK0QBOu)O$OYGD$g%d@uYS2&=I{`q#mwaB5 zEEtW(Edp?nGju{H|j%edU zM}5jm5*-YzD4d8}bt0H?0k_UZJ?dLCy$t_)0qq!6KvNjGSVRmGYu{b;U-cwnW}zhl z6NGpCRrY!N=d$z5+teCv36{>!i2W4#@^0KQQCRCN7k0{bG5WBW+*M~LdPPl%l`DAf zwnB(5(`Q9${xWMCN5>)_hg+R7Z}r8*E7&a%|#27(Yh=6U9b9S$(I-eHys28JwXTXLP~6HFIFAeNeBo~ zG50RldkGH?hSRC5p%p!JPf^jp@E-^s~6SOSSiH zwt5LRUS{%1Duhl<7QkJBauUkKuTZ>vHG$>BkU=TR4gxiR#xch(cv<8VE?S-3c_-LG7)ji#&DmHbaqg^0LWwt;pTQ#Hxa z?jX1lCHwuxfSEo3c*Hp`zQo`L->moK-YfNW)~L`>ASpJ1GlMJV!nfZrJXSvYWbTY4 zR(rz0(d4At!BeF-Km5X2f}K04FM(gacmMDlD*RW&mFxF$p81@J(50dJSD=JaexJb$ zlj6f$MGT1oW+GC22fY{!UZf8mMD%oZQBV}0?*`5{c9hmcORMouNx-b1AD3!r{$!!e z;$Y^w{aN+(TI?~&L-|YslI{SqD;8F&B8gm_eeL1Q!DS+!xu9&R2!KI6`m=}GXt{?$ zUn^OHtzD+;Mdu?`t)P4+=f4jgZdZSMKR?wTNz_RZ7}&;R`8o?c^@V|Xl1g8Cno8PO z_z54Mn6Cll@P1s=D6g;fwT)jJAjS%l^0cf)6xHd(Sc$(A`gYj31Bn4sK*# zO~Tki*A!sy$|y)m5DrOAOCw}6uYafOhSYY_#jjXU+M} zmFzVma_7d(6+$M7UOaJ|(63Gj#KDvQBP|T$f!gUcxE}|o^?eXn_%`#MFEsCn3fkYh zGa`OCt9$IA>cCq$`laK><#i?|W_HW@;?9;0D!2J3<$Zl@ot3R;a6r0*9kWkH@qXi> zu0E^$C&8>bI@EglUleMI4n?g%Z#&l`sWsTvHqezz684yZq1BlIwC%h&HCN5%>?sREj#in3pe-`obPOoY=e*I&Mjl9P+nsALMWs55VDGnRjRlTlUubonw-++9l0 zHIFp7M{lj_u-D=jukg=-t>xdMSz>?KSoA<3(bdaw2WHtzxb zbO#IPZk$3)Hoc&@xBw^7*@T3kzOY4_Z9{91rj@#?`{<|#!A%F}T*k+hvo*CQ(3lI( zi$|-Wg!NOSJp`q{_2;BLi}RC2g5DEDk=4V2x!U3H-riS}hd$jIh0b;tMMlPenVDKJ zF%)b2FYEnn-|>0#bTP#G-CmEB+8UPeTD+o7<^EqLW}c|!mZ4{`*_ly5`Ih$w+@J^< zP$ZZAV*tR99_1XHm_GmX&`-Xrrh1KE)4QkhNV44U75AvN>~Sr_mfTW5zQBgt5l0nn zTuPYf>hD)CHYGlwJO->EH6QVU(WTL=NoiELm*DGYMcO1ik9rvspJ{VsZ(TWZqf}P% zM$0M^>;zpSUaLFV?8Rhm9=0!`eS37+FNJvL%Oqj z2kY!7Ojy9Eqon6WCI(unW$nzF4W-(GI}3quKL= z2cW5|7>_v^*`ijn8c`?@?avE4pFan-N48ZSIT@>|)wp7+L9l%I(5dd_;vk!Z^D4W; zueIsG!-KL6CFV5!@JioP}Oz6YwujSY$+Z!{P~ML{spYjJcpg4Yx3BbYr{FOCZnC7A8g3) z2R@2_sWGH)?CiSkwZux~%Cx>*=B@RYzfaeN z*HZ`=hGxXZ=GblM!%dvn*uHRF{PGXH zn7LFnvUt_o>Dh5+Kkr|8$jy@(eL+YnAUF$~>C4q$lZ1ciy*^bxJtQ`2NMg@Gch(_x z*Zj*T=bMu=aQ}i-Ssks_MRUv8$+v)Yy|uhEc(Qk*y>nD8S%|diw~FLVG;pbW-q7~= z+@;!EpA|~9`2XP1?4JXl9t@rHU#BA>sZ}kDh&lW8sUr)EuJX`tnVf$h_I(N4*(ZKV z0y_TjGs5&9MDCXUPxgX9cZ^kd-^eQ~`B{^FlNT1i)TDeGN5&KRbLz{Dnetbkd@`{Z zBQO`3exDO&23GplID`D~wHx_&Y8Y3|51^o8GpD7a5mTn|ZNisOSY48i8gul)V2U^& zj-rxv{5}-}idQpCW^?~wFP7x_y53KTI}Q$xMF9!b%T*Y)g<_Gr9=W{xkp2GDX}gV% zg;fX|^pa8PW?ygbY=4L5Smm;?kW}$}EwrnrD>5ppSG|M|reNx@OIU_*sX#SvQKchI zem+x-!-da`415nV)f7VWU%r12{wiBMiZj9p??I{H-G$|=dXk-JC`hNqL$2Kr+LV%$ z+T~AasR|4Sxk)774#<#cCOD z_Y-m5dauECch!U`YK~Wz;@OL8<5FP-VQ#F?x`M^gC~sa7!91ISe%?~Oa({@$WPIsA zP}Ohc9EybGsc8#X^(-D8t)79w=Y@n*e2eSkhw;R()V=k-AkN0~iHb7fsApH>ceU)6 zf<^a&rXpjAHXu>^QBkI67QW`g+)UX#UIP7J`b^P8*hPPh17d+qpCpbdR>!foN;VHG zGKqdalN0mnwgt}po7q)Q+JFNpW}&Dk$Q_4N&4l4#I(a8U_^ zDL~!Wj1NMVG9$rU@7h5K;=+tBFV=6Dup1B6wpQaF;)SfE?|JOk*mc?{?5UW=z zhqJL>M}KM+_)UU4YE5~-#QF72 za=1BENB7M9$H#>A)N%wXc$HXp2h+0YFM8|g9Rh^v@sh#5rvkO+v$64LD9A(n!XugV zLX)PILjP`!^(F`_4}OGt$J_-5uLu0MMDDxi`z!7R8UJYm65Z(4bq6kY+*Bj3ioC5K zmH&sYw+zd2>)M5H8bLxrN&#t50YO6P?oOozL6B~wO9??br5hxaE@_oe8c78N2?^DV=q%w z{`ww)m}us4=BIrPc^sUTaJ5Ht*B9%ZmY`vQk`WI*jHaffTTE`lK*yM^&(wTZc-M}< z>a~~$K2!(yTAQoXV;-r!Q`@^K=ymuTJ4KC=B}$*a!$SQyPi9@%zum0h-;vjWw%E|7|)c zH5hI%tu8-;OLTdCL zK6u~~aEU5aY^t{0*cKOtAa>eHS@obch5%Wr2krL%KzD+|L~ z6XN>K%ki~XDl=yvuJrR8ObUBH^RFj~z6uRcHsup8*)&uvMCO8o8{f5tI~KS|pw~** z!!nr=J&5Z^!OTltF3x&Y6@+Ev z9IP+pzxjr22yAZT)9+%ic&Ki-uM@m_K2#b;S0f8ek=7M4D|fdO1c&c4AK1;<=%T?E zYZZuTu`wirjZU-QGH%KiC(2Rz{0g=@9^M`|cSlkUgB42-K3vHAhx{9p#e1x zeJPlkKZY2t2RNzn)2$d16DV0j(&po)e+XDv5}F}-4)_Kh=nFKU+T{wK-xuN;^gf8v1NSK zN`d+y;H_LNQ!JBG&!=RH2&dkRDj za5sm@Va=;fU-Q3*_KE=G<*0G-fE4VgI)%a!VQn_T`9qn$WNs|M(l>8Dy(wI~eq`() zBCcr|T%YJjvr2hPa|ey>As#Ui5p-vWOJNH0AKoY$Rz$om19;O;UGa%PVrgvHhyeL-~zd-fO4PTxFB>3F-IusYKSM z2baI?_dV*mLWB6dF|+p}Vy~m)z~}t+P>XM^R*Ct0cZZe5-kZ$Ib=3S7_}4PaPy2mq zRMF6qIJ{uHgz|8H#HS@xWJO^5cSR@-{cw{-PRZr?Ms9>s#S1EK>m2NDdt7Uqw1wq> zi3?et=m(xxMipa=xF{)CVK_6MTuhmqVFfxc2F)OKI}p{^ky7hQbQ!kTDn7>#bxRA@ z6&605NfJs*9220EAG*5oewN8j61wFvhcsH38#L}i5WI({=gyH=MSq$A*&0Ol2E}mb z*9~Nfq5VU}$+8iVm+RM~>M^%)Jbn7~dxOhOHny-n@vg$skP^Bhn-c9(y2|+@8)(gL zFfubTw%r<`$cNZ}#4sH57nb0}c=+ziRIMF|s6zDA)S?TU$fmi@|I`dGESzX^f@k$V_&}}ZWpli zx#m0ARY7n$FwY2!!whjPK=D3x{~1XCJjA)0hO(*>C^3aiL~PZs;&Fob&#!=Mhk3E} zs>#(aG`f;ur13f?8+p?&QevDhWU8(w>Pq0^;=W8=&=WTq>Z2*2Y`_-5T@F`u%pSke zYpDNT3Q&loXiT-VXXH#W`g(6!jYp}?%|$BOO*yWu?k8xQwxnVaU!>m)Um>1*Ct$OO zY5sQp^}QX1@T;HMjf9WSz30;eP&D#ie(DJ`Yq;Tpl`I7L%m7QQ$E;Pce;N!`wH))Z5(nBLAT{QAe_B8 zrwNL|M4X;`uHa1;X^7n63!=qVmx+47z#5~@d9+}7AL=$361KM{q$f-ooGiF)Y+x_PZBx@% z;pOcSoupY_HU1OTsaT;SbX-qc)GeEcK#kCB{FrQVl-K>}K=6A<(-WGIiCGRsEFh)& zn5CREVu;WBu@VV$dywst)w^y@f67(*OvP;$d3}i&`$S{oSG%IynD|>^KWIZ)qC?RY z8*2=yymDp9QN8H0<@W^wyV5YvO&{1VkwdiZ%>94E1Uu0z4+&0MF3wZ{1-tbh@d8Q@ zG*}^z`;zW(3IOBBrJx=S5>|Qhy*&lHH96O4;9)7mZEbDMSd~b-?er?m@sdgV?a-q2 zGobAi@j4`A+TGoqwX?NlzlM{vJXT8OKuoq~I#I?l)8wI{Y3P$0GN)4f6*3DNzLRzT zgbVaQpUBMu)ahod9?ehTa+w@M6hUWfuB-pEgN@SNMbI)NM@5Myv`4bs8QQ&vPx7Wv zb6@!Dz<}ziQkCSj>g~V zPbC&#XWZ_esdJ!Lgk>U%MQfeszvs{vRgm{2zEO?;jzkDgg0uMuWF+sJ+`;9xT=7tFDQ$jV@Dbv3+3|xaM8fV?%AEFh zO!SYO+$a9NO6jOCp0x)Amk>|~gqq*hyW?#Rq*q6i0#)So2U_ zU0p=_xvvj4t_XXxeIA@EB(08fZ6BYSik?=C*6 zSXUU090E$dZT!8rXADXOsRkJAh1^O?qbjA#YHK zFlFUQ@h|04(Z=hE=k33p_gAgI2st}B=&*)HkG7pc!1b1*#4QH4^7d(kqWiLfBiSiO zG-|(wP}x#oE79|#DlI4?ywykn4KIM->-BYs5mZbOI?}jz(2)!XN692Awavu zD^z-6l5lZBO?B4>=f&jW^45>;q6M6m1NB=o+*_`|$U(0{aVNV!Q%u{^a@Y6sSZO4@ zGKiC@S{>vp>HhXQxz3v;m`JV=R)m|iR#{t;khujMPEF#wxfv;W`J6gjQG{HJe1pb> zw{Ji0Y!gLN&yZaG*{yv`oz-lg{4d(#B`wd8m3$O5F7>{@R??bZ?2qycXnj@P94P%E z&7qSb(Pz?MnC|+n@5W75Ie#CUwt((FDbSlib&`sq`(nKPyq=UepUT*BV(WNs_{T?r zOP8H2C57{2BH|kNq$74?Vwz0o?rbUk8vAU?I84rGi+%L` zB|ni4y2`3sQ$WB|`Mh#Thv#9S-wff95LIRdbq@kjBO>rjNVT*` zA9jc618Lhk=zc}gFbcXX2VM$u3+A^iFb!yC2pd#a^E5hJQc-yLkY3#)crvhUBq~v7PX2htBq~sdC-FI@~rv5;zIpYa{J;O+c zL#D#X5L zu_yoNoBaJWC0hU1tkAX3+co3`%J4le%FagJ4++8EE)UxOvdeLxXgXC`xW))p+M2!neSCcU z=P4GCAH&+1K>%|}im7ptph9PFk-My_ErwX*MXX5vS{J7ucV=2dP2fgUFCGa zOVUYx5;xvwcOpy19sH2Ptg@_&D>ep^l#iMi3VQB)3ui~Hzp%bmapPcq1^*^1OD+-* zA`tjZ_NjQTT$qLShwpCH`HKgQbaZq45+u%adCu;l;jZh(uHRniEvHwMeV~Q*O3-7w zBrwpX(mVpiVu@m*xr@V4e`sthmwM2k#iv2$)fdjKa^JnvMKT#HgQvgzUl7;@g;Mb~ zDJeyW_}ucQ#1a-v_XI7;bG+)`>E>>V*_)4 z9`x=nYeRXZog?Z1^fm+{@jVO9Zbe_ShkkJ+Ey`(q#&j%CY9l_29Ps?PDbHIj*z4rE z*Ub#J(I^?Y5PqJ&7#Uf!vZ(Lhe+cCHrQYZM5i}xZogu=o2JB^o5PoGJo*dMPEe-@r ze7;;Cz=ppiY@hT+Ku*L-VQTZB;c#`q=_iYVIrdb3tix45iWknXe0sO+Y=<&Xa#pkW z8|cuZ?=WEFPQQE6za()O4_LsJ@tfEZxpxtM@^9`rFGtnsK{xvLta$UQ7dsujs3~aq4mg5y! z>J#+e`0T#|?X!nilPEpczZ%sdbQcvj-QjH4|zY#Z9wk9XIwNyyz#F||F?j2pFAoVNF%lPgXiSN=p z=cl}Pm#=v2-MVL+34v5>cMKyG|MX`A(2&|yP*G70^WNC#|I?QZfEU`tO;Av9b~hv} zOkPE$zrVi#iKc1_UB#3orwvV{??n_%6S2L2mED6bzIaYAI$Naas^0b;HaA5R@Hyxt zc@~8@h;|aV;GMmC^2>3g;=EJg?08SW=ahfuA=SI8DnZZvTQd(S7WEZzxNBJJE`nf6 zw<97+L@z#bI#UyTE40>XL|cM6MTRi1I~8T$o?pFV%|BC#YJ|v?Ro=hD!}G0f5GCK+ zTS4S|L2)rET?_eT@`3AXaQ2duO-9(Be*N;G-m#%#jT`misQ>CC^o)zMR|JevTAe00 zuNIN~1GzVduJ*W?NLXML1alLgF%tb-@(T3^Idi{mW8glEwnRzbxNtq$C*@Srbgr}< zmhMkCU~n~W5E&N#F&4ECjkMj;bigYUj!W5U50W^K*|_(xfiEh zKbjXoD{{fMcq`pXjtO!5b_7ToJOmFyiC+-){`&fMRMA6nl@bP(YY}8(3mBl9yr*qYx8EeGHZb|T`+W2| zLiM!{q5zswbiSX~q1T%OEM-U2-F*hq`ik8HsGrOMX()dS3pFeCNM zzxLgp5``M@zvz1Jdt@AgcLrKU=;kD@$!-roe3kJ-9UWLKT1$7nm~Rtm=6Lz$hJMjZ zR^DXn*GnC26_4!gIUhv#q@{@X3iqX?q~z!4UnL=d2h9mK1%bDLNugIr6_k<4t)8!5 zy^z=iyqn#ip_T64eYaAEbWZulM^?X8*1orhD1wJl+lzIoUS_JSxml=h|JPRnE8NnT zBnpw3AKz=vvG`~D$8L++hpD@!h)gAaXjU75?yk+`A8|0~wJD| zjX}+WQPYb?D*kd%-Nlv6&Q3{n$|r3B7;$Nh&<5VaclnIGT<=DamkWm*F~GzM+qS6r=R0V%p9 zu#h3#NoM&XT(@aNzCD>fEOFbhn>jwH{gkwFu814a*T?DN!owDtVQRpI$eb?qJ&yDG zJ$t{7fG$HU2W1~LJo(M~g``w>RY_?Ov>Wtrp(tFOt6IrPs`SEGU&$Isn6D?^{idkm zHcl7tiS^l)_UAvzRBU0xp!?*){(JP&u-1Bzt3osG7dITgih}IwV z3Vrb^%KH@j1Kaab96+I(6?K*>+$E~RLJ)>S;}G|NeOf?kxY@)73lX)0CKh$v*ITDK z885avzZ_;2EW-X8uet(nSrDYi!AqV=Wb4GIR5a)9cXd(kD=j3e9NR6+{R|61{hhs* z-{m>Oi`@=;U%_4T=+Prk{gYrJu+amcb^;6s*C8b->5V~SO+^LaT84=4H*jcy{}q(# zWn~+mqUnFk&lgs+#fNDYoz}>_qHe2!b%W!@S|uQUfy!;T^6Qir3kxfct8LKl0j$;H z`n9kidGuP)}0~_zh|YY>7u5l zrj_9WK=e8c0eyXutFBhBQ6WH0O+C}#GCVK<`2bt3{%FljP2XC4RT2_BGocop_P!}C z1=}2E>hg5`4%pe+KIzwj#>CpjrsZTqppcnl?=#=`QxMyb8uhqt4Ay``c?t|1%gf7A zIbvKKb5UXZ2YEO$mv*;)$e^L2>E>o z(cpJ>zyfVmaeq4kIHoN}GYZ52M#u9>o$~a){+87rmFsXwYaS(6i`U&~$?Tc^iso}_;;s4#a<_mX_*X*iX7=NIg`7!7=?2<{1~?L=@{^HQFxGPT z!|vwy+xI4x&Q2ul)4459OLX!)VnMQ@Y5yyhnc(|d)4Yl`ypPJt+(11a{hpI{-ZcUI zEtkP=tF*GMhR&Lio<8W1Mavx_>grnM?{90p=1_+l_^9Ncj_{5isT#T2z@K|*_`Ycf zBu-mDM8ppmYzx@8iFQ^(11onf*Ud^C3>HQk+HO3aOB9|z+9CHodmbH)g@aROGrcTY zin_c0)a3E#%JyQ;HNC_q44NJYgiP{cd$R`543)eEqSaf)jbDmTvSC4g*Mu_qJ_bdk zb~&gi<<-kMoGx)z<8RxWp1aGSD4Z#M)PKFHul_OvRrT(;?ZaFctb$`W

    vrI-9HR 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 literal 0 HcmV?d00001 diff --git a/etc/active-object.urm.puml b/etc/active-object.urm.puml new file mode 100644 index 000000000000..3fc3c8e1e921 --- /dev/null +++ b/etc/active-object.urm.puml @@ -0,0 +1,25 @@ +@startuml +package com.iluwatar.activeobject { + abstract class ActiveCreature { + - logger : Logger + - name : String + - requests : BlockingQueue + - thread : Thread + + ActiveCreature(name : String) + + eat() + + name() : String + + roam() + } + class App { + - creatures : Integer + - logger : Logger + + App() + + main(args : String[]) {static} + + run() + } + class Orc { + + Orc(name : String) + } +} +Orc --|> ActiveCreature +@enduml \ No newline at end of file diff --git a/etc/acyclic-visitor.png b/etc/acyclic-visitor.png new file mode 100644 index 0000000000000000000000000000000000000000..7b4df13d80f8c0d1be8ca32cbc39594bbd9ec7d4 GIT binary patch literal 49064 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 J8O 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 ZoomVisitor +AllModemVisitor --|> HayesVisitor +ConfigureForDosVisitor ..|> AllModemVisitor +ConfigureForUnixVisitor ..|> ZoomVisitor +Hayes --|> Modem +HayesVisitor --|> ModemVisitor +Zoom --|> Modem +ZoomVisitor --|> ModemVisitor +@enduml \ No newline at end of file diff --git a/etc/adapter.urm.png b/etc/adapter.urm.png new file mode 100644 index 0000000000000000000000000000000000000000..341ad67699d9d965433e169c91793e9fd164beb5 GIT binary patch literal 25425 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 A%m4rY literal 0 HcmV?d00001 diff --git a/etc/adapter.urm.puml b/etc/adapter.urm.puml new file mode 100644 index 000000000000..1277cbb87125 --- /dev/null +++ b/etc/adapter.urm.puml @@ -0,0 +1,31 @@ +@startuml +package com.iluwatar.adapter { + class App { + - App() + + main(args : String[]) {static} + } + class Captain { + - rowingBoat : RowingBoat + + Captain() + + Captain(boat : RowingBoat) + ~ row() + ~ setRowingBoat(boat : RowingBoat) + } + ~class FishingBoat { + - LOGGER : Logger {static} + ~ FishingBoat() + ~ sail() + } + class FishingBoatAdapter { + - boat : FishingBoat + + FishingBoatAdapter() + + row() + } + interface RowingBoat { + + row() {abstract} + } +} +FishingBoatAdapter --> "-boat" FishingBoat +Captain --> "-rowingBoat" RowingBoat +FishingBoatAdapter ..|> RowingBoat +@enduml \ No newline at end of file diff --git a/etc/aggregator-microservices.urm.puml b/etc/aggregator-microservices.urm.puml new file mode 100644 index 000000000000..02af47ddf261 --- /dev/null +++ b/etc/aggregator-microservices.urm.puml @@ -0,0 +1,2 @@ +@startuml +@enduml \ No newline at end of file diff --git a/etc/aggregator.gif b/etc/aggregator.gif new file mode 100644 index 0000000000000000000000000000000000000000..b06cdfb0c920bd2e8f9257ebcae452e81dac6acd GIT binary patch literal 2413 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 literal 0 HcmV?d00001 diff --git a/etc/ambassador.urm.png b/etc/ambassador.urm.png new file mode 100644 index 0000000000000000000000000000000000000000..9b50a02ad356106d5bde0979fcef0bbcafabb1f0 GIT binary patch literal 49248 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 LQ "-service" RemoteService +Client --> "-serviceAmbassador" ServiceAmbassador +RemoteService --> "-randomProvider" RandomProvider +RemoteService ..|> RemoteServiceInterface +ServiceAmbassador ..|> RemoteServiceInterface +@enduml \ No newline at end of file diff --git a/etc/api-gateway.png b/etc/api-gateway.png new file mode 100644 index 0000000000000000000000000000000000000000..bb3ec2e2e1a824699a539c89f362d2573e3860c9 GIT binary patch literal 18323 zcma%icQ{;M+wSPSBsvj7kf=eF=q=Ghf-(B2(M6A5f)IpY5H+Hk!RR%5?{!3r=$+`D zvn9XxyWaDiube;Ty7sKS+Ft8^%6guAg{i-kC&H)22Z2CDiVAYCK_Ij);Fpez4wPsr zjPHX$^16z0(wgs5wo?rd_r_tndLO@uMKGNWkA!kqaLd#amV|t{Cr?Ae@r5_?PRVkw zD>1SFMV|Ozp|hdRT6=rffMK=*?xuBfqgz_HskvRSqjfO>KQ7XR^9M5G1}bUg?qK*c z;#wzzz_@{5W3Z4i(ek<#8ym!9DtG31CD9S2OP>{P?nN5D7Z_%mWAR1o-3w$?xYIPH zj{$kmrGbX%7x1SD6r=dh1+XY6{mzD)J5jHdUH)9;>d<@X^~ecZ5C^750rkyoSz0EJ~ z`Znzk`j=utgTFr3Hir^1%RQ?eO~`{%AlrY5;@(Z;v$Wncd#^S3@%wo4I2|6zd#p;- zZU3tI^`9VkG>huIG!InYDn6o=5AASuk>Vh*(=*4;3WYqt?TOPiMeuSzM~+zXE-|*w znG9{;p^FfHQ{noqOp#m>MEl(W3ai3zU46)xU6R{?X^J4lT#hkv#|la$%WRAe8NM)N z3<`QLRWBw~oOumXm1-Xov=#UT??8+tyfa_)r%-ff%)QHxp;{(l7(fAT6EXFtxDI(H zu$Pr$k&!7d0RktwV8;Ix$7IeFEmc(4%@ca?$1_V{{rtPapuqV zZVUR4n{+K`q@y7;vt7!?bJH2czHiE(Yzx=K(t7yJrX_dpPtnhsBK7&)eq!lL17Bh~zflrKErsV} z?9=+WN$n7~b9#nC5hSlq{YMAp*FhYmr|%p<9OFUsk@~x_kRuy5_Y|)Smh9z(o3r*t z(Tec4LT?qR7N)CbJfRQyA&tT^<`g7B!^cD-S8%$6=lxiLG$gVfr3sJfH}(PDT?g2#jkBh>M} z6!3>xw|sh0bg1p)GaKM++;-mU&ZB?vd+u^l)=xE}zS{n}BWl;6(PA!SbH(A~gf`ET zX~SD+B<6XWPC91wB$4NF3<6=ti`+Dr7osu8Wz=>3U5xtTw`EFZw6D58< zIcaL-yLR?HDrHvfnx$CM%j}}Fu_oXWR-EF*0Dn6^xF~9z;j8VBt>aVuwaWl)rhNI? zEz?+s8-=T-pboKANtqU_GbsvMYae2aE9ia`DqE`F`h7r>Vf4JX-*;({Mu z>;ZdLkmFu%Rhf^$5p#74$d6X0=v3UaOF)HGDTDPEs{SxOn{FYfGm<}@my0>-%*RkJ0bI2}!AZ%q*j%^4`L`d=dmsd){)0{CGZNs6?DWJ!8zrrJ;@}x4PuD zOahQ)=u*zxTuVI`&7T*anq>E}Ntbgn%9o{R#m-xGa47QyBIl`1$34sVdoqqa(n(^` z@d5K+YWnTChXV+noq=0{RY|JOESYDWpMlD%1tso>Ph9?}Z4;s-BMwlV7H4#I2_#>9_03aL@XDuGgbWYj@zDXleBVZ)Qp?G#4q0I6Df4ZG6b?thsnpO^>0W?ldJ?j(qCK zBX5>L46?Ewn?LhowzN(Ld!!W#PD>xZ@NBp@G!UJ z!P!}NQP1*nNB~wZevfnygY-j0gGO3QHJOpR1$|-k&xWkc`p4*-c>n+l6KR#z;{gfr z{^mk0^jscWd^lB!lT$>LkE@qPlHEC3(SXqiJGtYDKdhiUR6q$KF~o%8ZAyw`X2MOz z`vyf$XTN`Sxu9r~Qm>BzZ$PJWE|W*>^;D)7Fg(1lG|k$dOM5*yfBfF{sYhu#_ELo9 z<#q{RLYC;c&Xy}9N|KtBFq7|2ExhWr*Op0sw>;pxm@Rq}w|p3nb*^QPrGThcmqb}+LB4r(~4+xHTiqgU=(-h~1yFEGJ%db@kd-|?iwAj-29 zhL{da$uE#CVnTpUrWMugm^D~%@%ti5@nXA&*Pmh~6~N@0<*k48|M$oN_AbW|&}eh- ziyFlTo9*rOiGXafDqYL1N{N|JKcd?^=>V~unjFq)ok9cN=W~TeZN@q!EgQ+dU#?K%3qep%+dX^Ff|Xg(f6M2|uz8Th(j+4!7ykX@_^_*vOTAAwt0nVBx<&&24m< zPzGDvD{p5MBc9Ui$NkWt7TY${?jik%41-qeu+(^oFf`EFfjIg^fpv9yf!N&@g|I>h zh@0V&7>KE7DJQlsM(Dfp+xnzN5d%S{h;w!SKr!P-j1AA#=9K1KsmGPF1G760{3&G7 zOi$^slZQk?Aj(|`UL?F*}aPjQQLjsTfFz#rP_2qH5wy1fzep8;WsCe z9;sy}cmG+haYJN*8et_MegEOob)a#u7Bl9yEKz9TKQLP3eByE+Um|Igr@}Z=9hK6U+)CECqobJHs*juT!&D zd-D15%*TKz^wfoFWzoUm7J6(X_|tk3U%inMZ&!YOSaqmB_9|Oy?-KN&V5OKF z-!15-SD}0jV}|q~OiyYF$dq5aAqNMjngIsPQ@;0=v{c{f9G-G!C(lAmlHym(!HwdF zX1v*spQm}_?ah->nceM)lwmn-YAmQIIciwI%dyOG6LaJ zHlCT!CYN|A=7y&R%1AML{WR4qFHZRd&+>(qf21ie7%POI9XHep1bY{Kg6jqL6Spb2 zU$U`Ht%OItZ^~<9!yCxg?0G{lH|cG%GZ`*_S5)O^Oz>1v5=j=%tDfJ&p~Vdqv)Nvn zs+k-Q1Gfh9;55k}XFEz?7qE2><)(MW-^v0WxYEM9&HCB&nSVaZS-GKVlW>Q%O=lw4 zkhLAh3w2hAWO-fPDoosKa68ftnNZI{02>cM=QwjWR(vNBtsReDV|QNwmJm7}!98!a z_4t0sl&0so;kHIo58w~7ziCSXOE+PIC9>k>yk8*M$1(e|^*Oi6F>EaD*l&9;{?T|g z@MdL4@(5~167AQmSE_Cp`G!!rE7vz{gYH2rvgK$Q3%%3V+z~=if_JW=Cqp(o(7pxulTW-Bm%_OP+Ndec1hRvT)f@b`X`C z%EnV9`Ba&*z$jZzd_JLb>$%7NM<1W{`vP$Zxb9=ytP`}-QG;7_FH3(I8%RVK5M#YN zI{3i{NX1BVk}-`enxZ#ZKUTMfmJIkNt{eX2(CzRwIumAYHnsE@D9iEswfJWGWlM(k z@%CA}P#3{I*s%HOs%%ZXuA&K}T+OA0P_q0HSzwKNwV!f8g=b7jU{m)>Vtqj$@F8JM zA`Jph;f+Qg4EP{nv+f&uhi)AE-h9X+|a;i#Tflu^4@7Sq?vrtBM%?0k+rS)svk1za>Cj0Lx zmZN>jVw$ZB7{3+vA{Ac;`EJwe$wy$r_V2fX1l*sVOQRh zlp*3~$%n>OnI}McrNm`qzvJt9COo82=aSdj6LOGzoU8M^8BidSIyo~vm^Kag=+D`u zsFkG^@_Q@d5cQb;gvEi25GJyZVk8{WsNicq9BT6@ITc~n&4B9dRyNO--s$$aQNv9 z*lk;St_iaaO~U>QJ<%F7uw!^)pyY?dGs_t;MWXXw_v@ikAK;-l|rjC}uHY^+{GJ=$N-Oxxd0a$u#s+|BQ%WA$!k zyLKZ;mgUw1@~@}?vqI>Mq@mPoD&a{?5y}fnrsrYAQIF1e*|;E*uS~2fadYd6_C+}_ zfc|T6Y#O>F0tfo5O^t+~$Np&H+x#_3bQ7D>s$nGUpPe3B+{X4bd7CVsExlBRqR#Dt zKK|An8)@F?Gz-b^KdiyzeUP#3V%-44Lv;XOWW;%dAre*o^!n)CFdy3AwK)a^1Ata` zEKLYU*OJ+N8*XU{wYb)3cUqHLs;;^x-rP3`738NRLup1Uv9PK5Lz=9JdWlM!tQj`_ zv$~?wzcZZ_(ItwdF?jI#s})pyS07z1hXuhJp!YNXke^2$wB-zQ?19;{ymt-4M;BCX zlncZIoCBcEcr49S{Ug!HLLyd+K`~XbpS{MmQ!j}YFRsmuR3$&Wl5Q$I`x4SA3n(O8 z`ofLw2y!H4s&ceyp(qH6@|{6a{zaRBibao+;Z0S${(EC@EplC1<8t}=<$y$<(#Fdp5Zi8CQlUGuvxA;LrcvRHa z*Lxmq)JAJil7!~G z%XTs!Ax`G}((gUP#!Pwypa$?i?@F^bYs|{?<~(5>QvX{&fs&HaZD&U3*%akfv%9`n72>hddS^ z13gkh1maW7_$v=0^(?9z9dUncC_~nL)>V5}{#76_8fUh@fIL>fL;l9owKp&dOnnLh zb+Wq9FL;wS8g`4qpS{bU=1UPGQF*A}xESdDF+_+OcHG})`5~o`#x+UbYH~I~<{|x) z1yuL$x;Jmqp&JJ^`C59uHWVA3b@elpaX4S`ZJ$1lU$(GQm< z9TWRrJcwWsZr$J4%~0{L;7%2GH0h1!a%Fh_#ab2g({r*3P^bP86SeHPPdG{-{u%7j zE)Owyw>g_OYH+pi^fo0v@&%&>aB7 zIKU0LvagclM7lZ2&P)9eGh!b0Z}O`<8C6^QNv|0ULaop?S%Wk0B8f9Qb=Nl69w!^W z;*R>XGk4tSciFAK$##;;=B1*;V?*&s>krrj)_`&A_Io%|cUjGhNL{d$_E?(zKffY) zK{FLpC@lM-wfSw{bHq8TG$V*_veWg%yhID+PAjy24MK%sA_ajs^LuusCfd@lGX8nJ zmafDwysjTg=r0x%hp1^kLdS*XAu59Rk0*+*2K)x=W&MR4fa{b#)6&cBaKV06Felf|chnJMx(CD=nLr zzc}PO%4Jzy8pnmE>I))Q3K_pfbAJ!?$CX$NeD~iQ$0sLtZ){@xkJ{N+8VuTxSRUC)NnLdtgR~Uz zkuTZlAkJE(PfB@!&WR9W<`pSIB5xM^UQd0&MYI^@Vj=FS$@q5%FdZv?da?YidZuRA zCH^x6CWoNt_wgbGFOmM12Bw$K2yM_+D`t#F2ZNOhOuM(!N2+nb*{S46Ygsh*ixjO# zmgo>2|AI!+V*N;JSP^GW%Ee1#ofLlxji+4?eg)V<>6hV*P=&^HL+K_F^5~`Kk*t18 zIa`r*tO>wbAP`+F*R^8_2FJ%r3mAVgXNO^P7e@O*sc_FK-+4~35K_WKI0`~3bUjcn z{wv~AzZA|^O7{+@3ooz9UF8r9AP@uEPzbvIfDc_e8Pa4&6p-Z&EfGkWidv)5w`X=K zdL0<(_x(QVhM@mAly5T829B(lJ$JR8=V}2XLVQm+dJETiF5?NKdL}Cd2jZnO25L`h zHRw~EKZWxgpj*@v02xhUgO1A#_qgsYv}?h^ z#~?`l4_k_zfWb`V1n$r2-vA3HdA^pJe%ANqt&J|063!;M)~zA=n$l^82G-fyH%i%M zJxxqbh93Zdr~Q4tGwIrej~v%)QP+7prdEIgPRa~yiiuu()GRN{fm_W^`IXh}4nJAx z#8%>>n~4>0{t^h(5$u4O$WfH#5$E?w0j^(&Dz*;7#Ulo?IfQyvzC0~)mu}O^!#=o4-Q;) z%KQg2%P{fi6n&@X&bnX8(obXRlo|E{l_E6iBYeBGn9-4 zvoQkD9F{6rXhQAigj#qDyQ-lLlSPY#V`0@_xLJ$kKKI^4c`q?*8~M2E<%^(0W)n%E z^b~oFzs3p*7=JDJ8-Q7!yr(GZJ}N+XtiIHNa&1b;+lZd+qCV}GJ+6`&{^8S+ujFiW z26n_kqr%zBW0$t2XNHI$uW3Sb461mc{c{cBdXqN$FI{)uYuSU~QQ&8gqg?qV7W9EQ zulCX1e8E9-_=y97kXKZMtZVo7oY+pN!z%csWq0Mys(6s=p}fB>30BR?OOKuRKxPAI zPY*G@i`Qy)9`o4|8{D|9-&paSi^$=--}KYg-d+1w#Di`Ry;p?3kO}=XWBwWNw3IWy zO_ZgYWCf0fkkA!?60I}i*qq1whzpw##*KU9(4LQNN1vZcPMJH?mgezrg^q0*71Y=v z^dOttaU&IP7Uuv+8!+_Gg=#f+dYRSc>Ke)0ve6^fPrl^dQ|yV14T*{frC1r-0CD6b zhQG^>NwcCi)k?n*oZ+}m@>Hwvpl>#R4DGKU6x&uXLxqzxmZ4|`I%-YYJ=5Ch;)MiFyShyJ8p-wycib4>h{r3C}MAyE=~b#&$@ zUcP%dH;|SzeLi#LE+%gn%TnPdx&0fcgbwlHRckswJn>b1cm7-a4at@-jMhUnK6<&r z?>X1MYA`e@t(^tyT~935-3&%W>5H8$`h9x=bYoW22Tt1>dDkmvJ1o^h?d*w>;mWHc z4mZ}W?(gP%gn>|hfQD#*Y(srk`){i3TEjZsh0ONX z%GL(`NNe;d@%trH+7MA-Il_alyUw|w;@xXt^z}hHHF=BPRfsvAROB6a!!z-iuM^9n zO85IVT{;^4FrdNsc+jJEYn)B(s?_uSLdm+_^{;^4UMXcnx{CPZQ<90~qwBY4KojE~rMrKY|sHTZ!DY|@?iLORRe}6d^ zB*S_cACahE1mAplw`9Qnw0m1f+(+-^5%1JgH$$Vep$5{|{)$(?gyP|BE+PQ7QpX#h zm5SEOP(mw&19`x(go(gnO<+s<{K&SUU!ZQS*7O2cnii_-PPN^c)5S@m&MMy(tEs7c zvKu*I^V%vML>#?8pACc*I5MO9G?>IqD8$i`GOloMBxSOG5ivqy;BPN`?u}=yH z7nNz=F00BW?;Aarh0MCI%5uAm?A);+jbw||9H!|Y>42EpT(hUiMdxQLAdaPg9vqvJ zZu6QdWVilEF?M%wT4JGA?OH75fXkW6bJLZi@8}#QnQE7<+navn2jP-8DA`rHx>aY% z>4x>(rDCwZ#e1z<4k;b!+7RmRtUgui6O`vG7Rb_YiqSQ$CVW`oezUHvlg?mwa=XU8vM)yM}y4|Tb#TZ+bfQf=IZU3>SL`+@=3zB+?)3D%_0A-*(Qb!asv-1hu0 z+5WRE%O+5Ym4xxf&;x4t>c8HyV{8^^X}f>Lf8Owx%Gbq-!6u-48Qm1&odak(icrr0 z;g3_%H5OC`RdSLoN+-lKtI5yy5pcHRf^>ai8to1{HC6W~o;ia*11`MFLIPYh`^aK71B~HS6r!>#KtFJeoO3vQq2N8sR^Wrhj9jMpHzknWj zPy({yjmc5*C!6|&Z_zpzWTQs}wX3N?<47)!Wdp@JRd&nPewP+AVjFA;yJHhLVeH3B z9qqOtI=!IBxA1!2)~MxE-0FKp(ODWR`G3-*i(WE;(2&^{;~$Te8z>|>6MW0(LE>`+ z@bH}`QLNe3A93g%WM7_Ci9PzhhkYnI9(DANe5J2BhJgmg1bJwtNGeNN`X-b)PHxCs zbrwi^?>q1;y=tVwe2^9Ro8}{n8;72^_PuTG9w&OebNq;lDJi*;cRwPTkxB0Vq(mci z2Js6-_g?az)KrfANT@cIYwTVke(qmk9o3TZ404!>-XqPp6!*Y|49OuA%K-bE^7L~g z4I1WtpGsPWggbfE7(<&&1D&GxqNDQNSJ_ie zz?OpKUUocmT2+oAH8heJRwIn+9y&TIJncDVx%3ADDdu5nS1*rDyYH*=s_<$rK-;4f zw=8H(1>Otb39=-#XU5MK1qtr;h<{QJysrjVxX$8S<^JXMN_(w?#E0;-q~ugvf^hm} zFgni2Zotvs6zK{wPx@a}s)xB%q*m7Xe2a6`yg?JAR;;r<_+TH7W3U6trI3-xPcQy- zXjfA*er;Gk1h8Vn_LngE4VrIqi0mER#<$#aq7*g7mTk1xeaPJM;4yn+Tpo!}d4-wf z{3Dc8l|6(CxsOfS$(^5R^u45?u}6M-XcSkYq1UEa`LB6vrh#bfC&tUkDz}=AvUrSzHbopR?oKoyPUBNj0%r z$E)VTB>|n+7eXj<42T}!mJP0OK~7S91AiYDG0aviF1@r~I&$^0XYIAQ83A&CHob+M zIHvnO!IvrZOox{TvqF98zNa-4={`rP&1Z9$F_&JpXWg^8?nXzyXu}Gp4o>&!C0NNe zy?O}77m~5{2$y)?*5_Wdx1?erK3#NbNtSA_MFTEn(R4FO7RKf&RY}aI&t16h_R=S3 zhsLa@`}>lOr|!9KpQ~X}ctd=x2Jw+Bp12jF8q|n=BmO3KY44O67gK;G^2$>_?Rncq zIBXeuI{aogZmnTDEoItmOIbdlQBBBuy^w!Syz1tVZt(L&=1vVMjfO)7%)ZC0cfdR4d+Yecm?IvW#%JVwm+}a!lzH~b zch}=mVxmw2SPvrT(WDsWW-W%E5SP8r#^tCP+}-zPXG_B<%WYR}rNQOW-lXdOq;z=3LiLcQJ-G#?q%^8oGcqkBJxB}Y~e@R-xYj;Xo?g>--9!`p~ z)JEyA7oVTkVyw1=9wqD=Rv*tdo|S#LPNMd3oV|=>n5*;cZy=iJpCd0$A5!ujOD?g^ z3odfhW#P^Ih*Zafmlp=xx2XG<&r};Z&NGUe2$0AF(N7%W5C$J0>bAo?yv9Z)xFuX8 zRe3&}?N@hQqH04acvsYSeyNN~&0&4ct2Ka2x2;x=-wO$l(#)YT$ZW2-CU!+{i&RBB zHWBtk-}c~P8xDxaJuV;qv;c}&?IZkHZ3(?jNhH9D`y_B7Xumyo)x3PeMAvYMf*U<6 z+1%4^0UeVhNLGLMJIQIE^zs#9DCP-CQ9R$+X9n8~);=%^*0M2w_Rsh4wrutS+`pB0 z+35y1r|a#x#$Mgi6OwDwn_j=h)fKv z!x<|fvl}3Ud9sl}A}<7fQZzZ#!zh*5GCafWi!RDRsCYdAsL!vyW|G0VciSfx-Qm0> zep8#>qa4irj+3$2*G!4)9x`Tu` zT~fg?x+-Km#?#yh4epVMG=98CIe|kr~ z|58@v1l@xwWKipaJF8=Qf7j79*N0uhiy!f7J{N-fyQ}A26zYv{(7;B00+3z5dC_FG zK5?%-1(OedQ@pSdeZn8ON$QCTy5HmxoGD9w%N5TSO)Nd%>!x}Zn!R6Nc!^$BuW^5# z8~>!WHyzHp8?h~s$b73)ikii6 zX30h=R1AG;{RYq38sDzLe7t=3i1q{P1rYHn`e$TL*~UHeYqsIB2P7c3}? z+g!fGFoVKA(@_vvv}Qo|O##fx)R!Aj>tH&FK|gD_V>&fxpJ-d7_HkrXkn+oH`c|>h z>hL7C95|Xye132PM_GhpqN3f%;P^Wvah%g0mR+@GpvK3Y?{TT9rAb?)$QM=0<~QDV z9Nv8Kcp^AJ1-Z}4ONd3yDwL-s$-9jMF}AP~gXBlzf#nPQ6$vVq4wc`=L^pjR6Vrn<`@w`E?DWvn>_qDHiJ!O+nSApad zbZ}Y?iZ45Pr1~vu{&trC`1>#`|M53)21JCCBD)rLr|>#?vbKU#(jzt`7Gi16uq)G- z2e;)w5SKaRlvd0tX!a#Dk5HS?)IT1b@TTfYDsiwC?9qwVr_9JY>!Q8GsU{Jpr^&YT z_zJ#XzjZUzJoZ`)>1O#(?{oi)-%*8{3I;+#ZyTy5)vcy2vdae54q|m^CPuAon>02G z{{MZul(trwrim4Qm<`k zZ^vd@A~wXQa;lkKn!TU^aAQpUVUn+BQg7L6KtPeuqXj?Cao?#hd5r@Jf8o_eTWmX> zFBqBPQSN9IFPmK;u7|=vfB7bsBdMUs-K3TihuOG>;7t8mmm5+TdCOQ!=>r&R8YR=P zAy&hhQE@D3wVtPWoU31#{?pIMs1#*QzGz>td*|j zv`w<~)3)W_giQ(jsIdb3M9<~iTVE?ld`w%f5pXU_9%F7opD?DMuMKCqGK9)oYYFvH zzb4DQ=$)}5Z}=7n>dSubgWB5K0z!wiv-Yz%3!jIGriXVyU?bb9CeO3|WgsnOSnCpY zd2xNQJK-bTfIEw%zaj?C4LL*zwwEc4^XwkHLPGApngW0TBUJ`nW#-)83*Kb?V)kVB zW4XW4ZYG}igaqwkLxYp~({IF0Q+!B4gR-)+L?io;Yq+3;34saygOy|ll$Syp?w)G9 z6Zud%CIWaHPfRc3GGX9eQZ*N(o~p3vc6i`*@zZP9 zz+)M9ME^-19ReuHptEI*?$F_X5^qjohImjQUUFw8AvybRAeEf})*O&e(S(mYXX@h- zQtrrScgmM;fv5oYAV6@cmP@BHm%rg$nwzn0x51QW8hd-Eto{_xBbnQY0a?BpBocZ_ zMmO>WNIU=2M2`FMYkT&GR1B^R(0(Ue6dt^SAb2IF?NttDGWW-632aHcDtUd5<+nQYf05_DVU%vX zm43?kRjwI~-0y~i?f@4)w5&~#=YBV_{<rbXI&rjWI(ctAI|~YA4_;2MyQW z7A>t~pl=KK3&@80Bt3ekdI#818B)zs5ZHg5=fSbnw_gI!K^#pR2~Tt<Ps#7wqV$;m&x}O?Oe_>1grI zvhvLtdMkQ<9UuL)NlqPZi*b9a1V~jf2s{67 zJrFXy_^z{WlBH%C3`tq<=q_k2&z-fmN3IyX+$63Bt~or>d$ha3J<8aW^x*HZKf*!? z-Ta2Ti;-Odp6NXazvy~Khv04D#B-mXoOZ?^<7!Pk`!}6IrQ@_vOATxML>tV9EX7C1 zlQEX`H3|{YYq|yIjANt3n&aq~ZdxyC1Lmn8$N~z_w_DE08H*@mT zB$YEts50DW(U@wfb5x}hM$r!2=1sHH-*o+EE0G3nEqyg94LJIEmAvb1v2(3K^5Pf- zknvdvh@i{wL1g|~k3&<@n_Hk1-*o-Q{r*9X;D76mB>k=$BUvLyjhxD&JvJ|QMdlD< zAx$Pme))@#H+`VultsgM6KsHnA~Y^9y50Wl|H=u`now+tYjamVU($-mRb(wz;YCbI z81ap&?%-1oSqIMhM#gFv?|Duo*6+*zh4!oSZSYCzIpz1+kM(b*X`%?L^rT5Oz4f2C{?5*U#U$Kmh^t87_vvF$l@q7i+>#zwopXuYt>Qzef z5Gd4nn=4TVsL6H^c(5M_*+YTZan9I5_`3Zgdg7Fd$E9XhRy#j(ta*ri7Erz>Aowa+ z6rxIjSw6n-13B^LOGdT}yG;D`;WrSI-{LlzF#DMf0#74`PzyVR{lkOZr)@4g(eB2l z`o8}fq|gw#QUD}|_VBvTZ7V>0;pjtSMW}~2oG>G|${XQgSalMny+`ir9_eRv4=(h7 z)>YUe<2{~7UlJbvgOq(F$a-^; zfKO?*MGmb)#+TBoqy~2=u~$4qr74_cR9=X+v^~VOA3*9 zCfY4F_ViCfcAbFqEHTy(YqTXaIB$332-KqT=1G@1N7nriA_O&lbV?gHudVWnj$Lhr z1C(F2rV*{L0+Fv$`I22cY8W~W~vz%tG$YucAiHwXCiFv5ib*jVqOcqlKmo)X{}Z4= zHXOH+Pc%dt5SUT=8*Nzy0y87PQIQT{uK*37{)2s>YCq3^7pid|vxE~Oej98P(@wja zCywHybAQB&xEKnkCAiwL{a{azgYbGODSf_VAX)3s*_}GpwYhmbqY^JF!8T<(?oZKh z&kleoMF+lL#f%K~-drxsrA|FJVemE3p@%T9Du!(_sj0bu?&#=ZqD&gdBz^mu zOJj_lj_VxVQaaJZXA{!8pR$-NKSt~P!)5ZKwyXnvBSO9< zGSy>DZ^j8w^%R(EY?_&p%{(FM$oR6uBp+ZH%bLd6%G+~c zqg-(+?R96)$If!Q&v!4cXD4$T6t;h+_xY@!&bHZ$mqsE?x7g`y*S5*)Da7XV7OhFO?7|5nX!Q3 z_-AlHcLF31g_CyKcqMjRVGc^D$+r|aF6T#0uYH;bkTIbvu>^E(Df*0?H#;MZ1~)%) z1PJKD=o{bePlo4K9qxXgZ=%#|OLF_z*;q2a`o;&cr9Ete4OVnKulAOXc03rlD2O`? zEB}Q92|s(8T>n}!?vm&rR1M3W~}(fWWlBAyV(c-S6#LV;3t=l=~15{Wx z7H^XrAAIrpF;IWzB8O=A&IQFySKqNYNYxUB$OGD4(?&KUP|Aum17+~jo~Oxk{%9F~ zU*EYm!_G+b+0F6pocZ+i1K40Xo52Xm%2znxD9-+1N?p&^HW?Gdh zMyX!k#E2qf8^6!J4%>!z4sh|RQ+(35o#IKLN2n2wGD_a>5dX{qO#4~gQwh}BDv9C6 zP_1i}pWE?|1O`vvUFJ6@v3}i~gZC$|_Z;jQ{gyeXs7)z8_Tu#5?>!HgSCZQRwTwN{ zvyaFq>BwboIKx_Bb212WxWme$Y^#OEhatEBVo2lz6@U=t638W24W( z=j|mU;EwNSFN-gfZple^FR1uS_$O9>k!yo@Mg0oDmVr>{{;A$=Y0TBOArzh0*++jQ&VEBKPqSilLOm_0K7K76} zfY}!T!RNr=-hV|A{Ph8dpuzk9_6V0jj;xM!_=*5Ajus!p^Ap3KmmIrQ=CyYXoqsXr z9TkX~(3geR`XKs0qixuQ9TJN2k$2yB z=G(+{MrM9`U@jaF7j+3TW!!doGv>0~165}rkB9A7%6U_ZUGjE%7C z&J`4=-l&}GDGHkC*`sa3U)H{ZEIkkv*=~Ey@2JZdKgcBVc-$Hv#eI7n?~NOfeVSjt zA9N-f4~h9C+$o>ZrebKXPzNt;!u@72!WvoD_IV|BpX9Dx+NPzcH7hEWJnGCAYtRm!6V2Pz0BhtCN% z2AW0z=CNg+68~{)ZgJo-E2xM7@mp8N5Cf8N$u8&tlS7Li7ICIhZK2GMZCf;&EgDm7 zvuP5J!(BU9ysKvZY}e_}g*oAqU;Yeq;aN+q$ZgHuJ6~MOc{yvP19Zr>f%z!?nUD7L zuBmG30N5n`wR=B1`m%ugZ4P7|pgQyv=VNawBnfjn=k8S-el7%@!S4XO;cVOuDF~e2 z2LBT({tY1i_86Yd(S_72R#K@Z(5{WnjObG52o4>m+GI32npScl9rFZO2h@Kov%2qp z{b;=3Lk0YtjrZ|;c;o<%0?wWP5uG+-$WIcL<=1L%SMBM(S3E}NgGS@N9aXK?=p6bw z?*S;<+(Q=m%!8*$NG^}5JzibV%n`$}5O2-7hy!(t_nO(CzP?eMLxPA`DB4OSE=w zH>-yLg)?yP^7m!rgs($O{g+Mbl#IHBmTU}l?^R15a7=uD#b?F@_#0UI-5Wd2 zJ^*7xuBOTJfTYp0lfQXz?zDOS0H+(cIb$g;9M$UQB~6|cBrvl`<+wfg&}IIO$6>?7 z8}pB`1z+|=oQ!CRsXoYZEe#9dd7>FHX+BhylrgR;b+4i3vwBiMx6xF9W@D(GG&@BX z+VrvUe2KuS?&22TrT_1psSwbEEn7t>(~C#-QJ=el(lLewP`-yUcpk4mspk=M-6IkGg-L2%an2f0;m<+Ck_Jc3_toPL!5_-N@sMAa&m-y9 zd4Um&R`()MpqK-88_DJ{N>mH@*Ru!RHb__owvGgc{%#dO`dfQ48&4RFeI@Mga^Rf zGNO^Tm{N53>P0Kxs1${8wKYT|j?mvC(!T8K@?Fzd0{0H9`REZq%12OtNcRK{q3*k! zRDbSrlXj%$J3qv6aeTQzw}j;ZFN)$Fk;CUU4>!J&dmE zSpBY!wgaK*{fMzC2M$;Bo(aR>@Vt|Y;t^@}O#wr!fRdN0SJJz8Rc%M(Pb98DBk4Z( zN;NZd`P6UD?Zk^x@@Ay2=KNr{GFQTZYY8{k#Oz8X^4)jB=(ee$Uj{9u(4%bWbvu?n zSAY5mjWPAhd)Qj#{jsNcqYbt&QRGLFsZXP4eRGWl&Xa>_N;9fG2k8}58PhCd9}X!x z$ZxD7q-!wPa&nUxF!^Zvh(4yjw9>gChrJ(%alndwBAhVpd*1+}_D!jfk@CmF1`&{;4E~LvYV3x z$SrxVIdC6+AC6~`phuX)=oGBpFd^~%>}VkdH6tsb$b9_lo-0*|+AA(#EItf`xr$-UKPv*Tajl+%5+X@B3do@s + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/etc/api-gateway.urm.puml b/etc/api-gateway.urm.puml new file mode 100644 index 000000000000..02af47ddf261 --- /dev/null +++ b/etc/api-gateway.urm.puml @@ -0,0 +1,2 @@ +@startuml +@enduml \ No newline at end of file diff --git a/etc/arrange-act-assert.urm.puml b/etc/arrange-act-assert.urm.puml new file mode 100644 index 000000000000..4b22d2a4e4bb --- /dev/null +++ b/etc/arrange-act-assert.urm.puml @@ -0,0 +1,11 @@ +@startuml +package com.iluwatar.arrangeactassert { + class Cash { + - amount : int + ~ Cash(amount : int) + ~ count() : int + ~ minus(subtrahend : int) : boolean + ~ plus(addend : int) + } +} +@enduml \ No newline at end of file diff --git a/etc/async-method-invocation.png b/etc/async-method-invocation.png new file mode 100644 index 0000000000000000000000000000000000000000..764895d7a217b838e4c884ced9df9d0d4888d28f GIT binary patch literal 36923 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 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/etc/async-method-invocation.urm.puml b/etc/async-method-invocation.urm.puml new file mode 100644 index 000000000000..6f5d0b27f9d4 --- /dev/null +++ b/etc/async-method-invocation.urm.puml @@ -0,0 +1,51 @@ +@startuml +package com.iluwatar.async.method.invocation { + class App { + - LOGGER : Logger {static} + + App() + - callback(name : String) : AsyncCallback {static} + - lazyval(value : T, delayMillis : long) : Callable {static} + - log(msg : String) {static} + + main(args : String[]) {static} + } + interface AsyncCallback { + + onComplete(T, Optional) {abstract} + } + interface AsyncExecutor { + + endProcess(AsyncResult) : T {abstract} + + startProcess(Callable) : AsyncResult {abstract} + + startProcess(Callable, AsyncCallback) : AsyncResult {abstract} + } + interface AsyncResult { + + await() {abstract} + + getValue() : T {abstract} + + isCompleted() : boolean {abstract} + } + class ThreadAsyncExecutor { + - idx : AtomicInteger + + ThreadAsyncExecutor() + + endProcess(asyncResult : AsyncResult) : T + + startProcess(task : Callable) : AsyncResult + + startProcess(task : Callable, callback : AsyncCallback) : AsyncResult + } + -class CompletableResult { + ~ COMPLETED : int {static} + ~ FAILED : int {static} + ~ RUNNING : int {static} + ~ callback : Optional> + ~ exception : Exception + ~ lock : Object + ~ state : int + ~ value : T + ~ CompletableResult(callback : AsyncCallback) + + await() + + getValue() : T + + isCompleted() : boolean + ~ setException(exception : Exception) + ~ setValue(value : T) + } +} +CompletableResult ..+ ThreadAsyncExecutor +ThreadAsyncExecutor ..|> AsyncExecutor +CompletableResult ..|> AsyncResult +@enduml \ No newline at end of file diff --git a/etc/aws-black.png b/etc/aws-black.png new file mode 100644 index 0000000000000000000000000000000000000000..7b5ba317856f8f1b05fb7c02c0b24f4bb955cd42 GIT binary patch literal 9262 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