facotry pattern of creational patterns

Author: meowpunch

pom.xml

@@ -13,5 +13,18 @@
         <maven.compiler.target>17</maven.compiler.target>
     </properties>
 
+    <dependencies>
+        <dependency>
+            <groupId>org.reflections</groupId>
+            <artifactId>reflections</artifactId>
+            <version>0.9.11</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.javatuples</groupId>
+            <artifactId>javatuples</artifactId>
+            <version>1.2</version>
+        </dependency>
+    </dependencies>
 
 </project>

src/main/java/creational/builder/Demo.java

@@ -1,6 +1,8 @@
 package creational.builder;
 
 
+import creational.builder.exercise.CodeBuilder;
+
 public class Demo {
 
     public static void main(String[] args) {
@@ -37,7 +39,6 @@ public static void main(String[] args) {
         System.out.println(builder);
 
 
-
         // Class Builder
         CodeBuilder cb = new CodeBuilder("Person").addField("age", "int").addField("name", "String");
         System.out.println(cb);

src/main/java/creational/builder/CodeBuilder.java renamed to src/main/java/creational/builder/exercise/CodeBuilder.java

@@ -1,4 +1,4 @@
-package creational.builder;
+package creational.builder.exercise;
 
 import java.util.ArrayList;
 import java.util.List;

src/main/java/creational/factory/HotDrinkMachine.java

@@ -0,0 +1,151 @@
+package creational.factory;
+
+import org.javatuples.Pair;
+import org.reflections.Reflections;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.*;
+
+interface IHotDrink
+{
+    void consume();
+}
+
+class Tea implements IHotDrink
+{
+    @Override
+    public void consume()
+    {
+        System.out.println("This tea is nice but I'd prefer it with milk.");
+    }
+}
+
+class Coffee implements IHotDrink
+{
+    @Override
+    public void consume()
+    {
+        System.out.println("This coffee is delicious");
+    }
+}
+
+interface IHotDrinkFactory
+{
+    IHotDrink prepare(int amount);
+}
+
+class TeaFactory implements IHotDrinkFactory
+{
+    @Override
+    public IHotDrink prepare(int amount)
+    {
+        System.out.println(
+                "Put in tea bag, boil water, pour "
+                        + amount + "ml, add lemon, enjoy!"
+        );
+        return new Tea();
+    }
+}
+
+class CoffeeFactory implements IHotDrinkFactory
+{
+
+    @Override
+    public IHotDrink prepare(int amount)
+    {
+        System.out.println(
+                "Grind some beans, boil water, pour "
+                        + amount + " ml, add cream and sugar, enjoy!"
+        );
+        return new Coffee();
+    }
+}
+
+class HotDrinkMachine
+{
+    public enum AvailableDrink
+    {
+        COFFEE, TEA
+    }
+
+    private Map<AvailableDrink, IHotDrinkFactory> factories =
+            new HashMap<>();
+
+    private List<Pair<String, IHotDrinkFactory>> namedFactories =
+            new ArrayList<>();
+
+    public HotDrinkMachine() throws Exception
+    {
+        // option 1: use an enum
+        for (AvailableDrink drink : AvailableDrink.values())
+        {
+            String s = drink.toString();
+            String factoryName = "" + Character.toUpperCase(s.charAt(0)) + s.substring(1).toLowerCase();
+            Class<?> factory = Class.forName("creational.factory." + factoryName + "Factory");
+            factories.put(drink, (IHotDrinkFactory) factory.getDeclaredConstructor().newInstance());
+        }
+
+        // option 2: find all implementors of IHotDrinkFactory
+        Set<Class<? extends IHotDrinkFactory>> types =
+                new Reflections("creational.factory") // ""
+                        .getSubTypesOf(IHotDrinkFactory.class);
+        for (Class<? extends IHotDrinkFactory> type : types)
+        {
+            namedFactories.add(new Pair<>(
+                    type.getSimpleName().replace("Factory", ""),
+                    type.getDeclaredConstructor().newInstance()
+            ));
+        }
+    }
+
+    public IHotDrink makeDrink() throws IOException
+    {
+        System.out.println("Available drinks");
+        for (int index = 0; index < namedFactories.size(); ++index)
+        {
+            Pair<String, IHotDrinkFactory> item = namedFactories.get(index);
+            System.out.println("" + index + ": " + item.getValue0());
+        }
+
+        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
+        while (true)
+        {
+            String s;
+            int i, amount;
+            if ((s = reader.readLine()) != null
+                    && (i = Integer.parseInt(s)) >= 0
+                    && i < namedFactories.size())
+            {
+                System.out.println("Specify amount: ");
+                s = reader.readLine();
+                if (s != null
+                        && (amount = Integer.parseInt(s)) > 0)
+                {
+                    return namedFactories.get(i).getValue1().prepare(amount);
+                }
+            }
+            System.out.println("Incorrect input, try again.");
+        }
+    }
+
+    public IHotDrink makeDrink(AvailableDrink drink, int amount)
+    {
+        return ((IHotDrinkFactory)factories.get(drink)).prepare(amount);
+    }
+}
+
+class AbstractFactoryDemo
+{
+    public static void main(String[] args) throws Exception
+    {
+        HotDrinkMachine machine = new HotDrinkMachine();
+        IHotDrink tea = machine.makeDrink(HotDrinkMachine.AvailableDrink.TEA, 200);
+        tea.consume();
+
+        // interactive
+        IHotDrink drink = machine.makeDrink();
+        drink.consume();
+    }
+}

src/main/java/creational/factory/exercise/PersonFactory.java

@@ -0,0 +1,21 @@
+package creational.factory.exercise;
+
+import java.util.stream.Stream;
+
+record Person(int id, String name) {}
+
+public class PersonFactory {
+    int numOfPerson = 0;
+
+    public Person createPerson(String name) {
+        return new Person(numOfPerson++, name);
+    }
+}
+
+class ExerciseDemo {
+    public static void main(String[] args) {
+        final PersonFactory pf = new PersonFactory();
+
+        Stream.of("Tommy", "Sunguck", "Meow").forEach(n -> System.out.println(pf.createPerson(n)));
+    }
+}