Skip to content

Commit 072a885

Browse files
iluwatariluwatar
committed
Merge branch 'master' into layers
Conflicts: layers/src/main/java/com/iluwatar/layers/App.java layers/src/main/java/com/iluwatar/layers/Cake.java layers/src/main/java/com/iluwatar/layers/CakeBakingException.java layers/src/main/java/com/iluwatar/layers/CakeBakingService.java layers/src/main/java/com/iluwatar/layers/CakeBakingServiceImpl.java layers/src/main/java/com/iluwatar/layers/CakeDao.java layers/src/main/java/com/iluwatar/layers/CakeInfo.java layers/src/main/java/com/iluwatar/layers/CakeLayer.java layers/src/main/java/com/iluwatar/layers/CakeLayerDao.java layers/src/main/java/com/iluwatar/layers/CakeLayerInfo.java layers/src/main/java/com/iluwatar/layers/CakeTopping.java layers/src/main/java/com/iluwatar/layers/CakeToppingDao.java layers/src/main/java/com/iluwatar/layers/CakeToppingInfo.java layers/src/main/resources/applicationContext.xml
2 parents 2bf00fb + fdb9be1 commit 072a885

File tree

61 files changed

+1238
-816
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

61 files changed

+1238
-816
lines changed

‎README.md‎

Lines changed: 1 addition & 759 deletions
Large diffs are not rendered by default.

‎abstract-factory/index.md‎

Lines changed: 26 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
1+
---
2+
layout: pattern
3+
title: Abstract Factory
4+
folder: abstract-factory
5+
permalink: /patterns/abstract-factory/
6+
categories:
7+
- pattern_cat
8+
- creational
9+
tags: pattern_tag
10+
---
11+
12+
**Intent:** Provide an interface for creating families of related or dependent
13+
objects without specifying their concrete classes.
14+
15+
![alt text](./etc/abstract-factory_1.png "Abstract Factory")
16+
17+
**Applicability:** Use the Abstract Factory pattern when
18+
19+
* a system should be independent of how its products are created, composed and represented
20+
* a system should be configured with one of multiple families of products
21+
* a family of related product objects is designed to be used together, and you need to enforce this constraint
22+
* you want to provide a class library of products, and you want to reveal just their interfaces, not their implementations
23+
24+
**Real world examples:**
25+
26+
* [javax.xml.parsers.DocumentBuilderFactory](http://docs.oracle.com/javase/8/docs/api/javax/xml/parsers/DocumentBuilderFactory.html)

‎adapter/index.md‎

Lines changed: 24 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
---
2+
layout: pattern
3+
title: Adapter
4+
folder: adapter
5+
permalink: /patterns/adapter/
6+
categories: pattern_cat
7+
tags: pattern_tag
8+
---
9+
10+
**Intent:** Convert the interface of a class into another interface the clients
11+
expect. Adapter lets classes work together that couldn't otherwise because of
12+
incompatible interfaces.
13+
14+
![alt text](./etc/adapter_1.png "Adapter")
15+
16+
**Applicability:** Use the Adapter pattern when
17+
18+
* you want to use an existing class, and its interface does not match the one you need
19+
* you want to create a reusable class that cooperates with unrelated or unforeseen classes, that is, classes that don't necessarily have compatible interfaces
20+
* 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.
21+
22+
**Real world examples:**
23+
24+
* [java.util.Arrays#asList()](http://docs.oracle.com/javase/8/docs/api/java/util/Arrays.html#asList%28T...%29)

‎async-method-invocation/index.md‎

Lines changed: 27 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,27 @@
1+
---
2+
layout: pattern
3+
title: Async Method Invocation
4+
folder: async-method-invocation
5+
permalink: /patterns/async-method-invocation/
6+
categories: pattern_cat
7+
tags: pattern_tag
8+
---
9+
10+
**Intent:** Asynchronous method invocation is pattern where the calling thread
11+
is not blocked while waiting results of tasks. The pattern provides parallel
12+
processing of multiple independent tasks and retrieving the results via
13+
callbacks or waiting until everything is done.
14+
15+
![alt text](./etc/async-method-invocation.png "Async Method Invocation")
16+
17+
**Applicability:** Use async method invocation pattern when
18+
19+
* you have multiple independent tasks that can run in parallel
20+
* you need to improve the performance of a group of sequential tasks
21+
* you have limited amount of processing capacity or long running tasks and the
22+
caller should not wait the tasks to be ready
23+
24+
**Real world examples:**
25+
26+
* [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)
27+
* [Task-based Asynchronous Pattern](https://msdn.microsoft.com/en-us/library/hh873175.aspx) (.NET)

‎bridge/index.md‎

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,22 @@
1+
---
2+
layout: pattern
3+
title: Bridge
4+
folder: bridge
5+
permalink: /patterns/bridge/
6+
categories: pattern_cat
7+
tags: pattern_tag
8+
---
9+
10+
**Intent:** Decouple an abstraction from its implementation so that the two can
11+
vary independently.
12+
13+
14+
![alt text](./etc/bridge_1.png "Bridge")
15+
16+
**Applicability:** Use the Bridge pattern when
17+
18+
* 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.
19+
* 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
20+
* changes in the implementation of an abstraction should have no impact on clients; that is, their code should not have to be recompiled.
21+
* 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
22+
* 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.

‎builder/index.md‎

Lines changed: 24 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
---
2+
layout: pattern
3+
title: Builder
4+
folder: builder
5+
permalink: /patterns/builder/
6+
categories: creational
7+
tags: pattern_tag
8+
---
9+
10+
**Intent:** Separate the construction of a complex object from its
11+
representation so that the same construction process can create different
12+
representations.
13+
14+
![alt text](./etc/builder_1.png "Builder")
15+
16+
**Applicability:** Use the Builder pattern when
17+
18+
* the algorithm for creating a complex object should be independent of the parts that make up the object and how they're assembled
19+
* the construction process must allow different representations for the object that's constructed
20+
21+
**Real world examples:**
22+
23+
* [java.lang.StringBuilder](http://docs.oracle.com/javase/8/docs/api/java/lang/StringBuilder.html)
24+
* [Apache Camel builders](https://github.com/apache/camel/tree/0e195428ee04531be27a0b659005e3aa8d159d23/camel-core/src/main/java/org/apache/camel/builder)

‎business-delegate/index.md‎

Lines changed: 21 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,21 @@
1+
---
2+
layout: pattern
3+
title: Business Delegate
4+
folder: business-delegate
5+
permalink: /patterns/business-delegate/
6+
categories: pattern_cat
7+
tags: pattern_tag
8+
---
9+
10+
**Intent:** The Business Delegate pattern adds an abstraction layer between
11+
presentation and business tiers. By using the pattern we gain loose coupling
12+
between the tiers and encapsulate knowledge about how to locate, connect to,
13+
and interact with the business objects that make up the application.
14+
15+
![alt text](./etc/business-delegate.png "Business Delegate")
16+
17+
**Applicability:** Use the Business Delegate pattern when
18+
19+
* you want loose coupling between presentation and business tiers
20+
* you want to orchestrate calls to multiple business services
21+
* you want to encapsulate service lookups and service calls

‎callback/index.md‎

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,22 @@
1+
---
2+
layout: pattern
3+
title: Callback
4+
folder: callback
5+
permalink: /patterns/callback/
6+
categories: pattern_cat
7+
tags: pattern_tag
8+
---
9+
10+
**Intent:** Callback is a piece of executable code that is passed as an
11+
argument to other code, which is expected to call back (execute) the argument
12+
at some convenient time.
13+
14+
![alt text](./etc/callback.png "Callback")
15+
16+
**Applicability:** Use the Callback pattern when
17+
18+
* when some arbitrary synchronous or asynchronous action must be performed after execution of some defined activity.
19+
20+
**Real world examples:**
21+
22+
* [CyclicBarrier] (http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/CyclicBarrier.html#CyclicBarrier%28int,%20java.lang.Runnable%29) constructor can accept callback that will be triggered every time when barrier is tripped.

‎chain-of-responsibility/index.md‎

Lines changed: 25 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
---
2+
layout: pattern
3+
title: Chain of responsibility
4+
folder: chain-of-responsibility
5+
permalink: /patterns/chain-of-responsibility/
6+
categories: pattern_cat
7+
tags: pattern_tag
8+
---
9+
10+
**Intent:** Avoid coupling the sender of a request to its receiver by giving
11+
more than one object a chance to handle the request. Chain the receiving
12+
objects and pass the request along the chain until an object handles it.
13+
14+
![alt text](./chain/etc/chain_1.png "Chain of Responsibility")
15+
16+
**Applicability:** Use Chain of Responsibility when
17+
18+
* more than one object may handle a request, and the handler isn't known a priori. The handler should be ascertained automatically
19+
* you want to issue a request to one of several objects without specifying the receiver explicitly
20+
* the set of objects that can handle a request should be specified dynamically
21+
22+
**Real world examples:**
23+
24+
* [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)
25+
* [Apache Commons Chain](https://commons.apache.org/proper/commons-chain/index.html)

‎command/index.md‎

Lines changed: 32 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,32 @@
1+
---
2+
layout: pattern
3+
title: Command
4+
folder: command
5+
permalink: /patterns/command/
6+
categories: pattern_cat
7+
tags: pattern_tag
8+
---
9+
10+
**Intent:** Encapsulate a request as an object, thereby letting you
11+
parameterize clients with different requests, queue or log requests, and
12+
support undoable operations.
13+
14+
![alt text](./etc/command.png "Command")
15+
16+
**Applicability:** Use the Command pattern when you want to
17+
18+
* 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.
19+
* 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
20+
* 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 Unexecute operation that reverses the effects of a previous call to execute. Executed commands are stored in a history list. Unlimited-level undo and redo is achieved by traversing this list backwards and forwards calling unexecute and execute, respectively
21+
* 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
22+
* 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
23+
24+
**Typical Use Case:**
25+
26+
* to keep a history of requests
27+
* implement callback functionality
28+
* implement the undo functionality
29+
30+
**Real world examples:**
31+
32+
* [java.lang.Runnable](http://docs.oracle.com/javase/8/docs/api/java/lang/Runnable.html)

0 commit comments

Comments
 (0)