- * There are two variations of the Adapter pattern: The class adapter implements the adaptee's + * + *
There are two variations of the Adapter pattern: The class adapter implements the adaptee's * interface whereas the object adapter uses composition to contain the adaptee in the adapter * object. This example uses the object adapter approach. - *
- * The Adapter ({@link GnomeEngineer}) converts the interface of the target class ( + * + *
The Adapter ({@link GnomeEngineer}) converts the interface of the target class ( * {@link GoblinGlider}) into a suitable one expected by the client ({@link GnomeEngineeringManager} * ). - * */ public class App { /** - * Program entry point - * + * Program entry point. + * * @param args command line args */ public static void main(String[] args) { - Engineer manager = new GnomeEngineeringManager(); + Engineer manager = new GnomeEngineeringManager(new GnomeEngineer()); manager.operateDevice(); } } diff --git a/adapter/src/main/java/com/iluwatar/adapter/GnomeEngineeringManager.java b/adapter/src/main/java/com/iluwatar/adapter/GnomeEngineeringManager.java index a2faf1e5..ff4ddb61 100644 --- a/adapter/src/main/java/com/iluwatar/adapter/GnomeEngineeringManager.java +++ b/adapter/src/main/java/com/iluwatar/adapter/GnomeEngineeringManager.java @@ -1,20 +1,26 @@ package com.iluwatar.adapter; /** - * * GnomeEngineering manager uses {@link Engineer} to operate devices. - * */ public class GnomeEngineeringManager implements Engineer { private Engineer engineer; public GnomeEngineeringManager() { - engineer = new GnomeEngineer(); + + } + + public GnomeEngineeringManager(Engineer engineer) { + this.engineer = engineer; } @Override public void operateDevice() { engineer.operateDevice(); } + + public void setEngineer(Engineer engineer) { + this.engineer = engineer; + } } diff --git a/adapter/src/test/java/com/iluwatar/adapter/AdapterPatternTest.java b/adapter/src/test/java/com/iluwatar/adapter/AdapterPatternTest.java new file mode 100644 index 00000000..866bfb96 --- /dev/null +++ b/adapter/src/test/java/com/iluwatar/adapter/AdapterPatternTest.java @@ -0,0 +1,68 @@ +package com.iluwatar.adapter; + +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.verify; + +import java.util.HashMap; +import java.util.Map; + +import org.junit.Before; +import org.junit.Test; + +/** + * An adapter helps two incompatible interfaces to work together. This is the real world definition + * for an adapter. Interfaces may be incompatible but the inner functionality should suit the need. + * The Adapter design pattern allows otherwise incompatible classes to work together by converting + * the interface of one class into an interface expected by the clients. + * + *
There are two variations of the Adapter pattern: + * The class adapter implements the adaptee's + * interface whereas the object adapter uses composition to contain the adaptee in the adapter + * object. This example uses the object adapter approach. + * + *
The Adapter ({@link GnomeEngineer}) converts the interface
+ * of the target class ({@link GoblinGlider}) into a suitable one expected by
+ * the client ({@link GnomeEngineeringManager}
+ * ).
+ */
+public class AdapterPatternTest {
+
+ private Map
- * Some of the services the Business Delegate uses are instantiated directly, and some can be
+ *
+ * Some of the services the Business Delegate uses are instantiated directly, and some can be
* retrieved through service lookups. The Business Delegate itself may contain business logic too
* potentially tying together multiple service calls, exception handling, retrying etc.
- *
- * In this example the client ({@link Client}) utilizes a business delegate (
+ *
+ * In this example the client ({@link Client}) utilizes a business delegate (
* {@link BusinessDelegate}) to execute a task. The Business Delegate then selects the appropriate
* service and makes the service call.
- *
*/
public class App {
/**
- * Program entry point
- *
+ * Program entry point.
+ *
* @param args command line args
*/
public static void main(String[] args) {
BusinessDelegate businessDelegate = new BusinessDelegate();
+ BusinessLookup businessLookup = new BusinessLookup();
+ businessLookup.setEjbService(new EjbService());
+ businessLookup.setJmsService(new JmsService());
+
+ businessDelegate.setLookupService(businessLookup);
businessDelegate.setServiceType(ServiceType.EJB);
Client client = new Client(businessDelegate);
diff --git a/business-delegate/src/main/java/com/iluwatar/business/delegate/BusinessDelegate.java b/business-delegate/src/main/java/com/iluwatar/business/delegate/BusinessDelegate.java
index b8a70aa0..a3c9a00e 100644
--- a/business-delegate/src/main/java/com/iluwatar/business/delegate/BusinessDelegate.java
+++ b/business-delegate/src/main/java/com/iluwatar/business/delegate/BusinessDelegate.java
@@ -1,22 +1,24 @@
package com.iluwatar.business.delegate;
/**
- *
* BusinessDelegate separates the presentation and business tiers
- *
*/
public class BusinessDelegate {
- private BusinessLookup lookupService = new BusinessLookup();
- private BusinessService businessService;
- private ServiceType serviceType;
+ private BusinessLookup lookupService;
+ private BusinessService businessService;
+ private ServiceType serviceType;
- public void setServiceType(ServiceType serviceType) {
- this.serviceType = serviceType;
- }
+ public void setLookupService(BusinessLookup businessLookup) {
+ this.lookupService = businessLookup;
+ }
- public void doTask() {
- businessService = lookupService.getBusinessService(serviceType);
- businessService.doProcessing();
- }
+ public void setServiceType(ServiceType serviceType) {
+ this.serviceType = serviceType;
+ }
+
+ public void doTask() {
+ businessService = lookupService.getBusinessService(serviceType);
+ businessService.doProcessing();
+ }
}
diff --git a/business-delegate/src/main/java/com/iluwatar/business/delegate/BusinessLookup.java b/business-delegate/src/main/java/com/iluwatar/business/delegate/BusinessLookup.java
index 7cea1658..310f7f43 100644
--- a/business-delegate/src/main/java/com/iluwatar/business/delegate/BusinessLookup.java
+++ b/business-delegate/src/main/java/com/iluwatar/business/delegate/BusinessLookup.java
@@ -1,17 +1,31 @@
package com.iluwatar.business.delegate;
/**
- *
- * Class for performing service lookups
- *
+ * Class for performing service lookups.
*/
public class BusinessLookup {
+ private EjbService ejbService;
+
+ private JmsService jmsService;
+
+ /**
+ * @param serviceType Type of service instance to be returned.
+ * @return Service instance.
+ */
public BusinessService getBusinessService(ServiceType serviceType) {
if (serviceType.equals(ServiceType.EJB)) {
- return new EjbService();
+ return ejbService;
} else {
- return new JmsService();
+ return jmsService;
}
}
+
+ public void setJmsService(JmsService jmsService) {
+ this.jmsService = jmsService;
+ }
+
+ public void setEjbService(EjbService ejbService) {
+ this.ejbService = ejbService;
+ }
}
diff --git a/business-delegate/src/test/java/com/iluwatar/business/delegate/AppTest.java b/business-delegate/src/test/java/com/iluwatar/business/delegate/AppTest.java
deleted file mode 100644
index 5ff7e678..00000000
--- a/business-delegate/src/test/java/com/iluwatar/business/delegate/AppTest.java
+++ /dev/null
@@ -1,19 +0,0 @@
-package com.iluwatar.business.delegate;
-
-import org.junit.Test;
-
-import com.iluwatar.business.delegate.App;
-
-/**
- *
- * Application test
- *
- */
-public class AppTest {
-
- @Test
- public void test() {
- String[] args = {};
- App.main(args);
- }
-}
diff --git a/business-delegate/src/test/java/com/iluwatar/business/delegate/BusinessDelegateTest.java b/business-delegate/src/test/java/com/iluwatar/business/delegate/BusinessDelegateTest.java
new file mode 100644
index 00000000..ebacd6b7
--- /dev/null
+++ b/business-delegate/src/test/java/com/iluwatar/business/delegate/BusinessDelegateTest.java
@@ -0,0 +1,78 @@
+package com.iluwatar.business.delegate;
+
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * The Business Delegate pattern adds an abstraction layer between the presentation and business
+ * tiers. By using the pattern we gain loose coupling between the tiers. The Business Delegate
+ * encapsulates knowledge about how to locate, connect to, and interact with the business objects
+ * that make up the application.
+ *
+ * Some of the services the Business Delegate uses are instantiated directly, and some can be
+ * retrieved through service lookups. The Business Delegate itself may contain business logic too
+ * potentially tying together multiple service calls, exception handling, retrying etc.
+ */
+public class BusinessDelegateTest {
+
+ private EjbService ejbService;
+
+ private JmsService jmsService;
+
+ private BusinessLookup businessLookup;
+
+ private BusinessDelegate businessDelegate;
+
+ /**
+ * This method sets up the instance variables of this test class. It is executed before the
+ * execution of every test.
+ */
+ @Before
+ public void setup() {
+ ejbService = spy(new EjbService());
+ jmsService = spy(new JmsService());
+
+ businessLookup = spy(new BusinessLookup());
+ businessLookup.setEjbService(ejbService);
+ businessLookup.setJmsService(jmsService);
+
+ businessDelegate = spy(new BusinessDelegate());
+ businessDelegate.setLookupService(businessLookup);
+ }
+
+ /**
+ * In this example the client ({@link Client}) utilizes a business delegate (
+ * {@link BusinessDelegate}) to execute a task. The Business Delegate then selects the appropriate
+ * service and makes the service call.
+ */
+ @Test
+ public void testBusinessDelegate() {
+
+ // setup a client object
+ Client client = new Client(businessDelegate);
+
+ // set the service type
+ businessDelegate.setServiceType(ServiceType.EJB);
+
+ // action
+ client.doTask();
+
+ // verifying that the businessDelegate was used by client during doTask() method.
+ verify(businessDelegate).doTask();
+ verify(ejbService).doProcessing();
+
+ // set the service type
+ businessDelegate.setServiceType(ServiceType.JMS);
+
+ // action
+ client.doTask();
+
+ // verifying that the businessDelegate was used by client during doTask() method.
+ verify(businessDelegate, times(2)).doTask();
+ verify(jmsService).doProcessing();
+ }
+}
diff --git a/command/pom.xml b/command/pom.xml
index 08ff32d3..6001ebc3 100644
--- a/command/pom.xml
+++ b/command/pom.xml
@@ -14,5 +14,10 @@
Four terms always associated with the command pattern are command, receiver, invoker and
+ * client. A command object (spell) knows about the receiver (target) and invokes a method of
+ * the receiver.Values for parameters of the receiver method are stored in the command. The receiver
+ * then does the work. An invoker object (wizard) knows how to execute a command, and optionally
+ * does bookkeeping about the command execution. The invoker does not know anything about a
+ * concrete command, it knows only about command interface. Both an invoker object and several
+ * command objects are held by a client object (app). The client decides which commands to execute
+ * at which points. To execute a command, it passes the command object to the invoker object.
+ */
+public class CommandTest {
+
+ private static final String GOBLIN = "Goblin";
+
+ /**
+ * This test verifies that when the wizard casts spells on the goblin. The wizard keeps track of
+ * the previous spells cast, so it is easy to undo them. In addition, it also verifies that the
+ * wizard keeps track of the spells undone, so they can be redone.
+ */
+ @Test
+ public void testCommand() {
+
+ Wizard wizard = new Wizard();
+ Goblin goblin = new Goblin();
+
+ wizard.castSpell(new ShrinkSpell(), goblin);
+ verifyGoblin(goblin, GOBLIN, Size.SMALL, Visibility.VISIBLE);
+
+ wizard.castSpell(new InvisibilitySpell(), goblin);
+ verifyGoblin(goblin, GOBLIN, Size.SMALL, Visibility.INVISIBLE);
+
+ wizard.undoLastSpell();
+ verifyGoblin(goblin, GOBLIN, Size.SMALL, Visibility.VISIBLE);
+
+ wizard.undoLastSpell();
+ verifyGoblin(goblin, GOBLIN, Size.NORMAL, Visibility.VISIBLE);
+
+ wizard.redoLastSpell();
+ verifyGoblin(goblin, GOBLIN, Size.SMALL, Visibility.VISIBLE);
+
+ wizard.redoLastSpell();
+ verifyGoblin(goblin, GOBLIN, Size.SMALL, Visibility.INVISIBLE);
+ }
+
+ /**
+ * This method asserts that the passed goblin object has the name as expectedName, size as
+ * expectedSize and visibility as expectedVisibility.
+ *
+ * @param goblin a goblin object whose state is to be verified against other parameters
+ * @param expectedName expectedName of the goblin
+ * @param expectedSize expected size of the goblin
+ * @param expectedVisibilty exepcted visibility of the goblin
+ */
+ private void verifyGoblin(Goblin goblin, String expectedName, Size expectedSize,
+ Visibility expectedVisibilty) {
+ assertEquals("Goblin's name must be same as expectedName", expectedName, goblin.toString());
+ assertEquals("Goblin's size must be same as expectedSize", expectedSize, goblin.getSize());
+ assertEquals("Goblin's visibility must be same as expectedVisibility", expectedVisibilty,
+ goblin.getVisibility());
+ }
+}
diff --git a/factory-method/pom.xml b/factory-method/pom.xml
index 0d1e435f..97c1c568 100644
--- a/factory-method/pom.xml
+++ b/factory-method/pom.xml
@@ -14,5 +14,10 @@
Factory produces the object of its liking.
+ * The weapon {@link Weapon} manufactured by the
+ * blacksmith depends on the kind of factory implementation it is referring to.
+ *