Update image paths for localizations

# Conflicts:
#	README.md
#	command/README.md

abstract-document/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Abstract Document
-folder: abstract-document
+category: Structural
-permalink: /patterns/abstract-document/
-categories: Structural
 language: en
 tags: 
  - Extensibility

abstract-factory/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Abstract Factory
-folder: abstract-factory
+category: Creational
-permalink: /patterns/abstract-factory/
-categories: Creational
 language: en
 tags:
  - Gang of Four

active-object/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Active Object
-folder: active-object
+category: Concurrency
-permalink: /patterns/active-object/
-categories: Concurrency
 language: en
 tags:
  - Performance

acyclic-visitor/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Acyclic Visitor
-folder: acyclic-visitor
+category: Behavioral
-permalink: /patterns/acyclic-visitor/
-categories: Behavioral
 language: en
 tags:
  - Extensibility

adapter/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Adapter
-folder: adapter
+category: Structural
-permalink: /patterns/adapter/
-categories: Structural
 language: en
 tags:
  - Gang of Four

aggregator-microservices/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Aggregator Microservices
-folder: aggregator-microservices
+category: Architectural
-permalink: /patterns/aggregator-microservices/
-categories: Architectural
 language: en
 tags:
 - Cloud distributed

ambassador/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Ambassador
-folder: ambassador
+category: Structural
-permalink: /patterns/ambassador/
-categories: Structural
 language: en
 tags:
   - Decoupling

api-gateway/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: API Gateway
-folder: api-gateway
+category: Architectural
-permalink: /patterns/api-gateway/
-categories: Architectural
 language: en
 tags:
   - Cloud distributed

arrange-act-assert/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Arrange/Act/Assert
-folder: arrange-act-assert
+category: Idiom
-permalink: /patterns/arrange-act-assert/
-categories: Idiom
 language: en
 tags:
  - Testing

async-method-invocation/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Async Method Invocation
-folder: async-method-invocation
+category: Concurrency
-permalink: /patterns/async-method-invocation/
-categories: Concurrency
 language: en
 tags:
  - Reactive

balking/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Balking
-folder: balking
+category: Concurrency
-permalink: /patterns/balking/
-categories: Concurrency
 language: en
 tags:
  - Decoupling

bridge/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Bridge
-folder: bridge
+category: Structural
-permalink: /patterns/bridge/
-categories: Structural
 language: en
 tags:
  - Gang of Four

builder/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Builder
-folder: builder
+category: Creational
-permalink: /patterns/builder/
-categories: Creational
 language: en
 tags:
  - Gang of Four

business-delegate/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Business Delegate
-folder: business-delegate
+category: Structural
-permalink: /patterns/business-delegate/
-categories: Structural
 language: en
 tags:
  - Decoupling

bytecode/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Bytecode
-folder: bytecode
+category: Behavioral
-permalink: /patterns/bytecode/
-categories: Behavioral
 language: en
 tags:
  - Game programming

caching/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Caching
-folder: caching
+category: Behavioral
-permalink: /patterns/caching/
-categories: Behavioral
 language: en
 tags:
   - Performance
@@ -43,39 +40,29 @@ Wikipedia says:
 **Programmatic Example**
 
 Let's first look at the data layer of our application. The interesting classes are `UserAccount`
-which is a simple Java object containing the user account details, and `DbManager` which handles
+which is a simple Java object containing the user account details, and `DbManager` interface which handles
-reading and writing of these objects to/from MongoDB database.
+reading and writing of these objects to/from database.
 
 ```java
-@Setter
+@Data
-@Getter
 @AllArgsConstructor
 @ToString
+@EqualsAndHashCode
 public class UserAccount {
   private String userId;
   private String userName;
   private String additionalInfo;
 }
 
-@Slf4j
+public interface DbManager {
-public final class DbManager {
 
-  private static MongoClient mongoClient;
+  void connect();
-  private static MongoDatabase db;
+  void disconnect();
   
-  private DbManager() { /*...*/ }
+  UserAccount readFromDb(String userId);
-
+  UserAccount writeToDb(UserAccount userAccount);
-  public static void createVirtualDb() { /*...*/ }
+  UserAccount updateDb(UserAccount userAccount);
-
+  UserAccount upsertDb(UserAccount userAccount);
-  public static void connect() throws ParseException { /*...*/ }
-
-  public static UserAccount readFromDb(String userId) { /*...*/ }
-
-  public static void writeToDb(UserAccount userAccount) { /*...*/ }
-
-  public static void updateDb(UserAccount userAccount) { /*...*/ }
-
-  public static void upsertDb(UserAccount userAccount) { /*...*/ }
 }
 ```
 
@@ -171,30 +158,43 @@ strategies.
 @Slf4j
 public class CacheStore {
 
+  private static final int CAPACITY = 3;
   private static LruCache cache;
+  private final DbManager dbManager;
 
   /* ... details omitted ... */
 
-  public static UserAccount readThrough(String userId) {
+  public UserAccount readThrough(final String userId) {
     if (cache.contains(userId)) {
-      LOGGER.info("# Cache Hit!");
+      LOGGER.info("# Found in Cache!");
       return cache.get(userId);
     }
-    LOGGER.info("# Cache Miss!");
+    LOGGER.info("# Not found in cache! Go to DB!!");
-    UserAccount userAccount = DbManager.readFromDb(userId);
+    UserAccount userAccount = dbManager.readFromDb(userId);
     cache.set(userId, userAccount);
     return userAccount;
   }
 
-  public static void writeThrough(UserAccount userAccount) {
+  public void writeThrough(final UserAccount userAccount) {
     if (cache.contains(userAccount.getUserId())) {
-      DbManager.updateDb(userAccount);
+      dbManager.updateDb(userAccount);
     } else {
-      DbManager.writeToDb(userAccount);
+      dbManager.writeToDb(userAccount);
     }
     cache.set(userAccount.getUserId(), userAccount);
   }
 
+  public void writeAround(final UserAccount userAccount) {
+    if (cache.contains(userAccount.getUserId())) {
+      dbManager.updateDb(userAccount);
+      // Cache data has been updated -- remove older
+      cache.invalidate(userAccount.getUserId());
+      // version from cache.
+    } else {
+      dbManager.writeToDb(userAccount);
+    }
+  }
+
   public static void clearCache() {
     if (cache != null) {
       cache.clear();
@@ -225,34 +225,39 @@ class.
 public final class AppManager {
 
   private static CachingPolicy cachingPolicy;
+  private final DbManager dbManager;
+  private final CacheStore cacheStore;
 
   private AppManager() {
   }
 
-  public static void initDb(boolean useMongoDb) { /* ... */ }
+  public void initDb() { /* ... */ }
 
   public static void initCachingPolicy(CachingPolicy policy) { /* ... */ }
 
   public static void initCacheCapacity(int capacity) { /* ... */ }
 
-  public static UserAccount find(String userId) {
+  public UserAccount find(final String userId) {
-    if (cachingPolicy == CachingPolicy.THROUGH || cachingPolicy == CachingPolicy.AROUND) {
+    LOGGER.info("Trying to find {} in cache", userId);
-      return CacheStore.readThrough(userId);
+    if (cachingPolicy == CachingPolicy.THROUGH
+            || cachingPolicy == CachingPolicy.AROUND) {
+      return cacheStore.readThrough(userId);
     } else if (cachingPolicy == CachingPolicy.BEHIND) {
-      return CacheStore.readThroughWithWriteBackPolicy(userId);
+      return cacheStore.readThroughWithWriteBackPolicy(userId);
     } else if (cachingPolicy == CachingPolicy.ASIDE) {
       return findAside(userId);
     }
     return null;
   }
 
-  public static void save(UserAccount userAccount) {
+  public void save(final UserAccount userAccount) {
+    LOGGER.info("Save record!");
     if (cachingPolicy == CachingPolicy.THROUGH) {
-      CacheStore.writeThrough(userAccount);
+      cacheStore.writeThrough(userAccount);
     } else if (cachingPolicy == CachingPolicy.AROUND) {
-      CacheStore.writeAround(userAccount);
+      cacheStore.writeAround(userAccount);
     } else if (cachingPolicy == CachingPolicy.BEHIND) {
-      CacheStore.writeBehind(userAccount);
+      cacheStore.writeBehind(userAccount);
     } else if (cachingPolicy == CachingPolicy.ASIDE) {
       saveAside(userAccount);
     }
@@ -272,24 +277,35 @@ Here is what we do in the main class of the application.
 @Slf4j
 public class App {
 
-  public static void main(String[] args) {
+  public static void main(final String[] args) {
-    AppManager.initDb(false);
+    boolean isDbMongo = isDbMongo(args);
-    AppManager.initCacheCapacity(3);
+    if(isDbMongo){
-    var app = new App();
+      LOGGER.info("Using the Mongo database engine to run the application.");
+    } else {
+      LOGGER.info("Using the 'in Memory' database to run the application.");
+    }
+    App app = new App(isDbMongo);
     app.useReadAndWriteThroughStrategy();
+    String splitLine = "==============================================";
+    LOGGER.info(splitLine);
     app.useReadThroughAndWriteAroundStrategy();
+    LOGGER.info(splitLine);
     app.useReadThroughAndWriteBehindStrategy();
+    LOGGER.info(splitLine);
     app.useCacheAsideStategy();
+    LOGGER.info(splitLine);
   }
 
   public void useReadAndWriteThroughStrategy() {
     LOGGER.info("# CachingPolicy.THROUGH");
-    AppManager.initCachingPolicy(CachingPolicy.THROUGH);
+    appManager.initCachingPolicy(CachingPolicy.THROUGH);
+
     var userAccount1 = new UserAccount("001", "John", "He is a boy.");
-    AppManager.save(userAccount1);
+
-    LOGGER.info(AppManager.printCacheContent());
+    appManager.save(userAccount1);
-    AppManager.find("001");
+    LOGGER.info(appManager.printCacheContent());
-    AppManager.find("001");
+    appManager.find("001");
+    appManager.find("001");
   }
 
   public void useReadThroughAndWriteAroundStrategy() { /* ... */ }
@@ -300,16 +316,6 @@ public class App {
 }
 ```
 
-Finally, here is some of the console output from the program.
-
-```
-12:32:53.845 [main] INFO com.iluwatar.caching.App - # CachingPolicy.THROUGH
-12:32:53.900 [main] INFO com.iluwatar.caching.App - 
---CACHE CONTENT--
-UserAccount(userId=001, userName=John, additionalInfo=He is a boy.)
-----
-```
-
 ## Class diagram
 
 ![alt text](./etc/caching.png "Caching")

caching/docker-compose.yml

@@ -0,0 +1,11 @@
+version: '3.7'
+services:
+  mongodb_container:
+    image: mongo:latest
+    environment:
+      MONGO_INITDB_ROOT_USERNAME: root
+      MONGO_INITDB_ROOT_PASSWORD: rootpassword
+    ports:
+      - 27017:27017
+    volumes:
+      - ./mongo-data/:/data/db

caching/pom.xml

@@ -39,19 +39,21 @@
       <scope>test</scope>
     </dependency>
     <dependency>
-      <groupId>org.mongodb</groupId>
+      <groupId>org.mockito</groupId>
-      <artifactId>mongodb-driver</artifactId>
+      <artifactId>mockito-junit-jupiter</artifactId>
-      <version>3.12.1</version>
+      <version>3.12.4</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.mockito</groupId>
+      <artifactId>mockito-all</artifactId>
+      <version>1.10.19</version>
+      <scope>test</scope>
     </dependency>
     <dependency>
       <groupId>org.mongodb</groupId>
-      <artifactId>mongodb-driver-core</artifactId>
+      <artifactId>mongo-java-driver</artifactId>
-      <version>3.0.4</version>
+      <version>3.4.1</version>
-    </dependency>
-    <dependency>
-      <groupId>org.mongodb</groupId>
-      <artifactId>bson</artifactId>
-      <version>3.0.4</version>
     </dependency>
   </dependencies>
   <!--

caching/src/main/java/com/iluwatar/caching/App.java

@@ -1,58 +1,62 @@
-/*
- * 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.
- */
-
 package com.iluwatar.caching;
 
+import com.iluwatar.caching.database.DbManager;
+import com.iluwatar.caching.database.DbManagerFactory;
 import lombok.extern.slf4j.Slf4j;
 
 /**
- * The Caching pattern describes how to avoid expensive re-acquisition of resources by not releasing
+ * The Caching pattern describes how to avoid expensive re-acquisition of
- * the resources immediately after their use. The resources retain their identity, are kept in some
+ * resources by not releasing the resources immediately after their use.
- * fast-access storage, and are re-used to avoid having to acquire them again. There are four main
+ * The resources retain their identity, are kept in some fast-access storage,
- * caching strategies/techniques in this pattern; each with their own pros and cons. They are;
+ * and are re-used to avoid having to acquire them again. There are four main
- * <code>write-through</code> which writes data to the cache and DB in a single transaction,
+ * caching strategies/techniques in this pattern; each with their own pros and
- * <code>write-around</code> which writes data immediately into the DB instead of the cache,
+ * cons. They are <code>write-through</code> which writes data to the cache and
- * <code>write-behind</code> which writes data into the cache initially whilst the data is only
+ * DB in a single transaction, <code>write-around</code> which writes data
- * written into the DB when the cache is full, and <code>cache-aside</code> which pushes the
+ * immediately into the DB instead of the cache, <code>write-behind</code>
- * responsibility of keeping the data synchronized in both data sources to the application itself.
+ * which writes data into the cache initially whilst the data is only
- * The <code>read-through</code> strategy is also included in the mentioned four strategies --
+ * written into the DB when the cache is full, and <code>cache-aside</code>
- * returns data from the cache to the caller <b>if</b> it exists <b>else</b> queries from DB and
+ * which pushes the responsibility of keeping the data synchronized in both
- * stores it into the cache for future use. These strategies determine when the data in the cache
+ * data sources to the application itself. The <code>read-through</code>
- * should be written back to the backing store (i.e. Database) and help keep both data sources
+ * strategy is also included in the mentioned four strategies --
- * synchronized/up-to-date. This pattern can improve performance and also helps to maintain
+ * returns data from the cache to the caller <b>if</b> it exists <b>else</b>
- * consistency between data held in the cache and the data in the underlying data store.
+ * queries from DB and stores it into the cache for future use. These strategies
+ * determine when the data in the cache should be written back to the backing
+ * store (i.e. Database) and help keep both data sources
+ * synchronized/up-to-date. This pattern can improve performance and also helps
+ * to maintainconsistency between data held in the cache and the data in
+ * the underlying data store.
  *
- * <p>In this example, the user account ({@link UserAccount}) entity is used as the underlying
+ * <p>In this example, the user account ({@link UserAccount}) entity is used
- * application data. The cache itself is implemented as an internal (Java) data structure. It adopts
+ * as the underlying application data. The cache itself is implemented as an
- * a Least-Recently-Used (LRU) strategy for evicting data from itself when its full. The four
+ * internal (Java) data structure. It adopts a Least-Recently-Used (LRU)
- * strategies are individually tested. The testing of the cache is restricted towards saving and
+ * strategy for evicting data from itself when its full. The four
- * querying of user accounts from the underlying data store ( {@link DbManager}). The main class (
+ * strategies are individually tested. The testing of the cache is restricted
- * {@link App} is not aware of the underlying mechanics of the application (i.e. save and query) and
+ * towards saving and querying of user accounts from the
- * whether the data is coming from the cache or the DB (i.e. separation of concern). The AppManager
+ * underlying data store( {@link DbManager}). The main class ( {@link App}
- * ({@link AppManager}) handles the transaction of data to-and-from the underlying data store
+ * is not aware of the underlying mechanics of the application
- * (depending on the preferred caching policy/strategy).
+ * (i.e. save and query) and whether the data is coming from the cache or the
+ * DB (i.e. separation of concern). The AppManager ({@link AppManager}) handles
+ * the transaction of data to-and-from the underlying data store (depending on
+ * the preferred caching policy/strategy).
  * <p>
- * <i>{@literal App --> AppManager --> CacheStore/LRUCache/CachingPolicy --> DBManager} </i>
+ * <i>{@literal App --> AppManager --> CacheStore/LRUCache/CachingPolicy -->
+ * DBManager} </i>
+ * </p>
+ *
+ * <p>
+ * There are 2 ways to launch the application.
+ *  - to use "in Memory" database.
+ *  - to use the MongoDb as a database
+ *
+ * To run the application with "in Memory" database, just launch it without parameters
+ * Example: 'java -jar app.jar'
+ *
+ * To run the application with MongoDb you need to be installed the MongoDb
+ * in your system, or to launch it in the docker container.
+ * You may launch docker container from the root of current module with command:
+ * 'docker-compose up'
+ * Then you can start the application with parameter --mongo
+ * Example: 'java -jar app.jar --mongo'
  * </p>
  *
  * @see CacheStore
@@ -61,23 +65,67 @@ import lombok.extern.slf4j.Slf4j;
  */
 @Slf4j
 public class App {
+  /**
+   * Constant parameter name to use mongoDB.
+   */
+  private static final String USE_MONGO_DB = "--mongo";
+  /**
+   * Application manager.
+   */
+  private final AppManager appManager;
+
+  /**
+   * Constructor of current App.
+   *
+   * @param isMongo boolean
+   */
+  public App(final boolean isMongo) {
+    DbManager dbManager = DbManagerFactory.initDb(isMongo);
+    appManager = new AppManager(dbManager);
+    appManager.initDb();
+  }
 
   /**
    * Program entry point.
    *
    * @param args command line args
    */
-  public static void main(String[] args) {
+  public static void main(final String[] args) {
-    AppManager.initDb(false); // VirtualDB (instead of MongoDB) was used in running the JUnit tests
+    // VirtualDB (instead of MongoDB) was used in running the JUnit tests
     // and the App class to avoid Maven compilation errors. Set flag to
     // true to run the tests with MongoDB (provided that MongoDB is
     // installed and socket connection is open).
-    AppManager.initCacheCapacity(3);
+    boolean isDbMongo = isDbMongo(args);
-    var app = new App();
+    if (isDbMongo) {
+      LOGGER.info("Using the Mongo database engine to run the application.");
+    } else {
+      LOGGER.info("Using the 'in Memory' database to run the application.");
+    }
+    App app = new App(isDbMongo);
     app.useReadAndWriteThroughStrategy();
+    String splitLine = "==============================================";
+    LOGGER.info(splitLine);
     app.useReadThroughAndWriteAroundStrategy();
+    LOGGER.info(splitLine);
     app.useReadThroughAndWriteBehindStrategy();
+    LOGGER.info(splitLine);
     app.useCacheAsideStategy();
+    LOGGER.info(splitLine);
+  }
+
+  /**
+   * Check the input parameters. if
+   *
+   * @param args input params
+   * @return true if there is "--mongo" parameter in arguments
+   */
+  private static boolean isDbMongo(final String[] args) {
+    for (String arg : args) {
+      if (arg.equals(USE_MONGO_DB)) {
+        return true;
+      }
+    }
+    return false;
   }
 
   /**
@@ -85,14 +133,14 @@ public class App {
    */
   public void useReadAndWriteThroughStrategy() {
     LOGGER.info("# CachingPolicy.THROUGH");
-    AppManager.initCachingPolicy(CachingPolicy.THROUGH);
+    appManager.initCachingPolicy(CachingPolicy.THROUGH);
 
     var userAccount1 = new UserAccount("001", "John", "He is a boy.");
 
-    AppManager.save(userAccount1);
+    appManager.save(userAccount1);
-    LOGGER.info(AppManager.printCacheContent());
+    LOGGER.info(appManager.printCacheContent());
-    AppManager.find("001");
+    appManager.find("001");
-    AppManager.find("001");
+    appManager.find("001");
   }
 
   /**
@@ -100,21 +148,21 @@ public class App {
    */
   public void useReadThroughAndWriteAroundStrategy() {
     LOGGER.info("# CachingPolicy.AROUND");
-    AppManager.initCachingPolicy(CachingPolicy.AROUND);
+    appManager.initCachingPolicy(CachingPolicy.AROUND);
 
     var userAccount2 = new UserAccount("002", "Jane", "She is a girl.");
 
-    AppManager.save(userAccount2);
+    appManager.save(userAccount2);
-    LOGGER.info(AppManager.printCacheContent());
+    LOGGER.info(appManager.printCacheContent());
-    AppManager.find("002");
+    appManager.find("002");
-    LOGGER.info(AppManager.printCacheContent());
+    LOGGER.info(appManager.printCacheContent());
-    userAccount2 = AppManager.find("002");
+    userAccount2 = appManager.find("002");
     userAccount2.setUserName("Jane G.");
-    AppManager.save(userAccount2);
+    appManager.save(userAccount2);
-    LOGGER.info(AppManager.printCacheContent());
+    LOGGER.info(appManager.printCacheContent());
-    AppManager.find("002");
+    appManager.find("002");
-    LOGGER.info(AppManager.printCacheContent());
+    LOGGER.info(appManager.printCacheContent());
-    AppManager.find("002");
+    appManager.find("002");
   }
 
   /**
@@ -122,23 +170,31 @@ public class App {
    */
   public void useReadThroughAndWriteBehindStrategy() {
     LOGGER.info("# CachingPolicy.BEHIND");
-    AppManager.initCachingPolicy(CachingPolicy.BEHIND);
+    appManager.initCachingPolicy(CachingPolicy.BEHIND);
 
-    var userAccount3 = new UserAccount("003", "Adam", "He likes food.");
+    var userAccount3 = new UserAccount("003",
-    var userAccount4 = new UserAccount("004", "Rita", "She hates cats.");
+            "Adam",
-    var userAccount5 = new UserAccount("005", "Isaac", "He is allergic to mustard.");
+            "He likes food.");
+    var userAccount4 = new UserAccount("004",
+            "Rita",
+            "She hates cats.");
+    var userAccount5 = new UserAccount("005",
+            "Isaac",
+            "He is allergic to mustard.");
 
-    AppManager.save(userAccount3);
+    appManager.save(userAccount3);
-    AppManager.save(userAccount4);
+    appManager.save(userAccount4);
-    AppManager.save(userAccount5);
+    appManager.save(userAccount5);
-    LOGGER.info(AppManager.printCacheContent());
+    LOGGER.info(appManager.printCacheContent());
-    AppManager.find("003");
+    appManager.find("003");
-    LOGGER.info(AppManager.printCacheContent());
+    LOGGER.info(appManager.printCacheContent());
-    UserAccount userAccount6 = new UserAccount("006", "Yasha", "She is an only child.");
+    UserAccount userAccount6 = new UserAccount("006",
-    AppManager.save(userAccount6);
+            "Yasha",
-    LOGGER.info(AppManager.printCacheContent());
+            "She is an only child.");
-    AppManager.find("004");
+    appManager.save(userAccount6);
-    LOGGER.info(AppManager.printCacheContent());
+    LOGGER.info(appManager.printCacheContent());
+    appManager.find("004");
+    LOGGER.info(appManager.printCacheContent());
   }
 
   /**
@@ -146,20 +202,26 @@ public class App {
    */
   public void useCacheAsideStategy() {
     LOGGER.info("# CachingPolicy.ASIDE");
-    AppManager.initCachingPolicy(CachingPolicy.ASIDE);
+    appManager.initCachingPolicy(CachingPolicy.ASIDE);
-    LOGGER.info(AppManager.printCacheContent());
+    LOGGER.info(appManager.printCacheContent());
 
-    var userAccount3 = new UserAccount("003", "Adam", "He likes food.");
+    var userAccount3 = new UserAccount("003",
-    var userAccount4 = new UserAccount("004", "Rita", "She hates cats.");
+            "Adam",
-    var userAccount5 = new UserAccount("005", "Isaac", "He is allergic to mustard.");
+            "He likes food.");
-    AppManager.save(userAccount3);
+    var userAccount4 = new UserAccount("004",
-    AppManager.save(userAccount4);
+            "Rita",
-    AppManager.save(userAccount5);
+            "She hates cats.");
+    var userAccount5 = new UserAccount("005",
+            "Isaac",
+            "He is allergic to mustard.");
+    appManager.save(userAccount3);
+    appManager.save(userAccount4);
+    appManager.save(userAccount5);
 
-    LOGGER.info(AppManager.printCacheContent());
+    LOGGER.info(appManager.printCacheContent());
-    AppManager.find("003");
+    appManager.find("003");
-    LOGGER.info(AppManager.printCacheContent());
+    LOGGER.info(appManager.printCacheContent());
-    AppManager.find("004");
+    appManager.find("004");
-    LOGGER.info(AppManager.printCacheContent());
+    LOGGER.info(appManager.printCacheContent());
   }
 }

caching/src/main/java/com/iluwatar/caching/AppManager.java

@@ -23,65 +23,80 @@
 
 package com.iluwatar.caching;
 
-import java.text.ParseException;
+import com.iluwatar.caching.database.DbManager;
+
 import java.util.Optional;
+
 import lombok.extern.slf4j.Slf4j;
 
 /**
- * AppManager helps to bridge the gap in communication between the main class and the application's
+ * AppManager helps to bridge the gap in communication between the main class
- * back-end. DB connection is initialized through this class. The chosen caching strategy/policy is
+ * and the application's back-end. DB connection is initialized through this
- * also initialized here. Before the cache can be used, the size of the cache has to be set.
+ * class. The chosen  caching strategy/policy is also initialized here.
- * Depending on the chosen caching policy, AppManager will call the appropriate function in the
+ * Before the cache can be used, the size of the  cache has to be set.
- * CacheStore class.
+ * Depending on the chosen caching policy, AppManager will call the
+ * appropriate function in the CacheStore class.
  */
 @Slf4j
-public final class AppManager {
+public class AppManager {
+  /**
+   * Caching Policy.
+   */
+  private CachingPolicy cachingPolicy;
+  /**
+   * Database Manager.
+   */
+  private final DbManager dbManager;
+  /**
+   * Cache Store.
+   */
+  private final CacheStore cacheStore;
 
-  private static CachingPolicy cachingPolicy;
+  /**
-
+   * Constructor.
-  private AppManager() {
+   *
+   * @param newDbManager database manager
+   */
+  public AppManager(final DbManager newDbManager) {
+    this.dbManager = newDbManager;
+    this.cacheStore = new CacheStore(newDbManager);
   }
 
   /**
-   * Developer/Tester is able to choose whether the application should use MongoDB as its underlying
+   * Developer/Tester is able to choose whether the application should use
-   * data storage or a simple Java data structure to (temporarily) store the data/objects during
+   * MongoDB as its underlying data storage or a simple Java data structure
-   * runtime.
+   * to (temporarily) store the data/objects during runtime.
    */
-  public static void initDb(boolean useMongoDb) {
+  public void initDb() {
-    if (useMongoDb) {
+    dbManager.connect();
-      try {
-        DbManager.connect();
-      } catch (ParseException e) {
-        LOGGER.error("Error connecting to MongoDB", e);
-      }
-    } else {
-      DbManager.createVirtualDb();
-    }
   }
 
   /**
    * Initialize caching policy.
+   *
+   * @param policy is a {@link CachingPolicy}
    */
-  public static void initCachingPolicy(CachingPolicy policy) {
+  public void initCachingPolicy(final CachingPolicy policy) {
     cachingPolicy = policy;
     if (cachingPolicy == CachingPolicy.BEHIND) {
-      Runtime.getRuntime().addShutdownHook(new Thread(CacheStore::flushCache));
+      Runtime.getRuntime().addShutdownHook(new Thread(cacheStore::flushCache));
     }
-    CacheStore.clearCache();
+    cacheStore.clearCache();
-  }
-
-  public static void initCacheCapacity(int capacity) {
-    CacheStore.initCapacity(capacity);
   }
 
   /**
    * Find user account.
+   *
+   * @param userId String
+   * @return {@link UserAccount}
    */
-  public static UserAccount find(String userId) {
+  public UserAccount find(final String userId) {
-    if (cachingPolicy == CachingPolicy.THROUGH || cachingPolicy == CachingPolicy.AROUND) {
+    LOGGER.info("Trying to find {} in cache", userId);
-      return CacheStore.readThrough(userId);
+    if (cachingPolicy == CachingPolicy.THROUGH
+            || cachingPolicy == CachingPolicy.AROUND) {
+      return cacheStore.readThrough(userId);
     } else if (cachingPolicy == CachingPolicy.BEHIND) {
-      return CacheStore.readThroughWithWriteBackPolicy(userId);
+      return cacheStore.readThroughWithWriteBackPolicy(userId);
     } else if (cachingPolicy == CachingPolicy.ASIDE) {
       return findAside(userId);
     }
@@ -90,41 +105,55 @@ public final class AppManager {
 
   /**
    * Save user account.
+   *
+   * @param userAccount {@link UserAccount}
    */
-  public static void save(UserAccount userAccount) {
+  public void save(final UserAccount userAccount) {
+    LOGGER.info("Save record!");
     if (cachingPolicy == CachingPolicy.THROUGH) {
-      CacheStore.writeThrough(userAccount);
+      cacheStore.writeThrough(userAccount);
     } else if (cachingPolicy == CachingPolicy.AROUND) {
-      CacheStore.writeAround(userAccount);
+      cacheStore.writeAround(userAccount);
     } else if (cachingPolicy == CachingPolicy.BEHIND) {
-      CacheStore.writeBehind(userAccount);
+      cacheStore.writeBehind(userAccount);
     } else if (cachingPolicy == CachingPolicy.ASIDE) {
       saveAside(userAccount);
     }
   }
 
-  public static String printCacheContent() {
+  /**
-    return CacheStore.print();
+   * Returns String.
+   *
+   * @return String
+   */
+  public String printCacheContent() {
+    return cacheStore.print();
   }
 
   /**
    * Cache-Aside save user account helper.
+   *
+   * @param userAccount {@link UserAccount}
    */
-  private static void saveAside(UserAccount userAccount) {
+  private void saveAside(final UserAccount userAccount) {
-    DbManager.updateDb(userAccount);
+    dbManager.updateDb(userAccount);
-    CacheStore.invalidate(userAccount.getUserId());
+    cacheStore.invalidate(userAccount.getUserId());
   }
 
   /**
    * Cache-Aside find user account helper.
+   *
+   * @param userId String
+   * @return {@link UserAccount}
    */
-  private static UserAccount findAside(String userId) {
+  private UserAccount findAside(final String userId) {
-    return Optional.ofNullable(CacheStore.get(userId))
+    return Optional.ofNullable(cacheStore.get(userId))
-        .or(() -> {
+            .or(() -> {
-          Optional<UserAccount> userAccount = Optional.ofNullable(DbManager.readFromDb(userId));
+              Optional<UserAccount> userAccount =
-          userAccount.ifPresent(account -> CacheStore.set(userId, account));
+                      Optional.ofNullable(dbManager.readFromDb(userId));
-          return userAccount;
+              userAccount.ifPresent(account -> cacheStore.set(userId, account));
-        })
+              return userAccount;
-        .orElse(null);
+            })
+            .orElse(null);
   }
 }

caching/src/main/java/com/iluwatar/caching/CacheStore.java

@@ -23,9 +23,11 @@
 
 package com.iluwatar.caching;
 
+import com.iluwatar.caching.database.DbManager;
 import java.util.List;
 import java.util.Optional;
 import java.util.stream.Collectors;
+
 import lombok.extern.slf4j.Slf4j;
 
 /**
@@ -33,16 +35,34 @@ import lombok.extern.slf4j.Slf4j;
  */
 @Slf4j
 public class CacheStore {
+  /**
+   * Cache capacity.
+   */
+  private static final int CAPACITY = 3;
 
-  private static LruCache cache;
+  /**
+   * Lru cache see {@link LruCache}.
+   */
+  private LruCache cache;
+  /**
+   * DbManager.
+   */
+  private final DbManager dbManager;
 
-  private CacheStore() {
+  /**
+   * Cache Store.
+   * @param dataBaseManager {@link DbManager}
+   */
+  public CacheStore(final DbManager dataBaseManager) {
+    this.dbManager = dataBaseManager;
+    initCapacity(CAPACITY);
   }
 
   /**
    * Init cache capacity.
+   * @param capacity int
    */
-  public static void initCapacity(int capacity) {
+  public void initCapacity(final int capacity) {
     if (cache == null) {
       cache = new LruCache(capacity);
     } else {
@@ -52,57 +72,64 @@ public class CacheStore {
 
   /**
    * Get user account using read-through cache.
+   * @param userId {@link String}
+   * @return {@link UserAccount}
    */
-  public static UserAccount readThrough(String userId) {
+  public UserAccount readThrough(final String userId) {
     if (cache.contains(userId)) {
-      LOGGER.info("# Cache Hit!");
+      LOGGER.info("# Found in Cache!");
       return cache.get(userId);
     }
-    LOGGER.info("# Cache Miss!");
+    LOGGER.info("# Not found in cache! Go to DB!!");
-    UserAccount userAccount = DbManager.readFromDb(userId);
+    UserAccount userAccount = dbManager.readFromDb(userId);
     cache.set(userId, userAccount);
     return userAccount;
   }
 
   /**
    * Get user account using write-through cache.
+   * @param userAccount {@link UserAccount}
    */
-  public static void writeThrough(UserAccount userAccount) {
+  public void writeThrough(final UserAccount userAccount) {
     if (cache.contains(userAccount.getUserId())) {
-      DbManager.updateDb(userAccount);
+      dbManager.updateDb(userAccount);
     } else {
-      DbManager.writeToDb(userAccount);
+      dbManager.writeToDb(userAccount);
     }
     cache.set(userAccount.getUserId(), userAccount);
   }
 
   /**
    * Get user account using write-around cache.
+   * @param userAccount {@link UserAccount}
    */
-  public static void writeAround(UserAccount userAccount) {
+  public void writeAround(final UserAccount userAccount) {
     if (cache.contains(userAccount.getUserId())) {
-      DbManager.updateDb(userAccount);
+      dbManager.updateDb(userAccount);
-      cache.invalidate(userAccount.getUserId()); // Cache data has been updated -- remove older
+      // Cache data has been updated -- remove older
+      cache.invalidate(userAccount.getUserId());
       // version from cache.
     } else {
-      DbManager.writeToDb(userAccount);
+      dbManager.writeToDb(userAccount);
     }
   }
 
   /**
    * Get user account using read-through cache with write-back policy.
+   * @param userId {@link String}
+   * @return {@link UserAccount}
    */
-  public static UserAccount readThroughWithWriteBackPolicy(String userId) {
+  public UserAccount readThroughWithWriteBackPolicy(final String userId) {
     if (cache.contains(userId)) {
-      LOGGER.info("# Cache Hit!");
+      LOGGER.info("# Found in cache!");
       return cache.get(userId);
     }
-    LOGGER.info("# Cache Miss!");
+    LOGGER.info("# Not found in Cache!");
-    UserAccount userAccount = DbManager.readFromDb(userId);
+    UserAccount userAccount = dbManager.readFromDb(userId);
     if (cache.isFull()) {
       LOGGER.info("# Cache is FULL! Writing LRU data to DB...");
       UserAccount toBeWrittenToDb = cache.getLruData();
-      DbManager.upsertDb(toBeWrittenToDb);
+      dbManager.upsertDb(toBeWrittenToDb);
     }
     cache.set(userId, userAccount);
     return userAccount;
@@ -110,12 +137,13 @@ public class CacheStore {
 
   /**
    * Set user account.
+   * @param userAccount {@link UserAccount}
    */
-  public static void writeBehind(UserAccount userAccount) {
+  public void writeBehind(final UserAccount userAccount) {
     if (cache.isFull() && !cache.contains(userAccount.getUserId())) {
       LOGGER.info("# Cache is FULL! Writing LRU data to DB...");
       UserAccount toBeWrittenToDb = cache.getLruData();
-      DbManager.upsertDb(toBeWrittenToDb);
+      dbManager.upsertDb(toBeWrittenToDb);
     }
     cache.set(userAccount.getUserId(), userAccount);
   }
@@ -123,7 +151,7 @@ public class CacheStore {
   /**
    * Clears cache.
    */
-  public static void clearCache() {
+  public void clearCache() {
     if (cache != null) {
       cache.clear();
     }
@@ -132,44 +160,51 @@ public class CacheStore {
   /**
    * Writes remaining content in the cache into the DB.
    */
-  public static void flushCache() {
+  public void flushCache() {
     LOGGER.info("# flushCache...");
     Optional.ofNullable(cache)
         .map(LruCache::getCacheDataInListForm)
         .orElse(List.of())
-        .forEach(DbManager::updateDb);
+        .forEach(dbManager::updateDb);
+    dbManager.disconnect();
   }
 
   /**
    * Print user accounts.
+   * @return {@link String}
    */
-  public static String print() {
+  public String print() {
     return Optional.ofNullable(cache)
         .map(LruCache::getCacheDataInListForm)
         .orElse(List.of())
         .stream()
         .map(userAccount -> userAccount.toString() + "\n")
-        .collect(Collectors.joining("", "\n--CACHE CONTENT--\n", "----\n"));
+        .collect(Collectors.joining("", "\n--CACHE CONTENT--\n", "----"));
   }
 
   /**
    * Delegate to backing cache store.
+   * @param userId {@link String}
+   * @return {@link UserAccount}
    */
-  public static UserAccount get(String userId) {
+  public UserAccount get(final String userId) {
     return cache.get(userId);
   }
 
   /**
    * Delegate to backing cache store.
+   * @param userId {@link String}
+   * @param userAccount {@link UserAccount}
    */
-  public static void set(String userId, UserAccount userAccount) {
+  public void set(final String userId, final UserAccount userAccount) {
     cache.set(userId, userAccount);
   }
 
   /**
    * Delegate to backing cache store.
+   * @param userId {@link String}
    */
-  public static void invalidate(String userId) {
+  public void invalidate(final String userId) {
     cache.invalidate(userId);
   }
 }

caching/src/main/java/com/iluwatar/caching/CachingPolicy.java

@@ -32,10 +32,25 @@ import lombok.Getter;
 @AllArgsConstructor
 @Getter
 public enum CachingPolicy {
+  /**
+   * Through.
+   */
   THROUGH("through"),
+  /**
+   * AROUND.
+   */
   AROUND("around"),
+  /**
+   * BEHIND.
+   */
   BEHIND("behind"),
+  /**
+   * ASIDE.
+   */
   ASIDE("aside");
 
+  /**
+   * Policy value.
+   */
   private final String policy;
 }

caching/src/main/java/com/iluwatar/caching/DbManager.java

@@ -1,171 +0,0 @@
-/*
- * 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.
- */
-
-package com.iluwatar.caching;
-
-import com.iluwatar.caching.constants.CachingConstants;
-import com.mongodb.MongoClient;
-import com.mongodb.client.MongoDatabase;
-import com.mongodb.client.model.UpdateOptions;
-import java.text.ParseException;
-import java.util.HashMap;
-import java.util.Map;
-import lombok.extern.slf4j.Slf4j;
-import org.bson.Document;
-
-/**
- * <p>DBManager handles the communication with the underlying data store i.e. Database. It contains
- * the implemented methods for querying, inserting, and updating data. MongoDB was used as the
- * database for the application.</p>
- *
- * <p>Developer/Tester is able to choose whether the application should use MongoDB as its
- * underlying data storage (connect()) or a simple Java data structure to (temporarily) store the
- * data/objects during runtime (createVirtualDB()).</p>
- */
-@Slf4j
-public final class DbManager {
-
-  private static MongoClient mongoClient;
-  private static MongoDatabase db;
-  private static boolean useMongoDB;
-
-  private static Map<String, UserAccount> virtualDB;
-
-  private DbManager() {
-  }
-
-  /**
-   * Create DB.
-   */
-  public static void createVirtualDb() {
-    useMongoDB = false;
-    virtualDB = new HashMap<>();
-  }
-
-  /**
-   * Connect to DB.
-   */
-  public static void connect() throws ParseException {
-    useMongoDB = true;
-    mongoClient = new MongoClient();
-    db = mongoClient.getDatabase("test");
-  }
-
-  /**
-   * Read user account from DB.
-   */
-  public static UserAccount readFromDb(String userId) {
-    if (!useMongoDB) {
-      if (virtualDB.containsKey(userId)) {
-        return virtualDB.get(userId);
-      }
-      return null;
-    }
-    if (db == null) {
-      try {
-        connect();
-      } catch (ParseException e) {
-        LOGGER.error("Error connecting to MongoDB", e);
-      }
-    }
-    var iterable = db
-        .getCollection(CachingConstants.USER_ACCOUNT)
-        .find(new Document(CachingConstants.USER_ID, userId));
-    if (iterable == null) {
-      return null;
-    }
-    Document doc = iterable.first();
-    String userName = doc.getString(CachingConstants.USER_NAME);
-    String appInfo = doc.getString(CachingConstants.ADD_INFO);
-    return new UserAccount(userId, userName, appInfo);
-  }
-
-  /**
-   * Write user account to DB.
-   */
-  public static void writeToDb(UserAccount userAccount) {
-    if (!useMongoDB) {
-      virtualDB.put(userAccount.getUserId(), userAccount);
-      return;
-    }
-    if (db == null) {
-      try {
-        connect();
-      } catch (ParseException e) {
-        LOGGER.error("Error connecting to MongoDB", e);
-      }
-    }
-    db.getCollection(CachingConstants.USER_ACCOUNT).insertOne(
-        new Document(CachingConstants.USER_ID, userAccount.getUserId())
-            .append(CachingConstants.USER_NAME, userAccount.getUserName())
-            .append(CachingConstants.ADD_INFO, userAccount.getAdditionalInfo())
-    );
-  }
-
-  /**
-   * Update DB.
-   */
-  public static void updateDb(UserAccount userAccount) {
-    if (!useMongoDB) {
-      virtualDB.put(userAccount.getUserId(), userAccount);
-      return;
-    }
-    if (db == null) {
-      try {
-        connect();
-      } catch (ParseException e) {
-        LOGGER.error("Error connecting to MongoDB", e);
-      }
-    }
-    db.getCollection(CachingConstants.USER_ACCOUNT).updateOne(
-        new Document(CachingConstants.USER_ID, userAccount.getUserId()),
-        new Document("$set", new Document(CachingConstants.USER_NAME, userAccount.getUserName())
-            .append(CachingConstants.ADD_INFO, userAccount.getAdditionalInfo())));
-  }
-
-  /**
-   * Insert data into DB if it does not exist. Else, update it.
-   */
-  public static void upsertDb(UserAccount userAccount) {
-    if (!useMongoDB) {
-      virtualDB.put(userAccount.getUserId(), userAccount);
-      return;
-    }
-    if (db == null) {
-      try {
-        connect();
-      } catch (ParseException e) {
-        LOGGER.error("Error connecting to MongoDB", e);
-      }
-    }
-    db.getCollection(CachingConstants.USER_ACCOUNT).updateOne(
-        new Document(CachingConstants.USER_ID, userAccount.getUserId()),
-        new Document("$set",
-            new Document(CachingConstants.USER_ID, userAccount.getUserId())
-                .append(CachingConstants.USER_NAME, userAccount.getUserName())
-                .append(CachingConstants.ADD_INFO, userAccount.getAdditionalInfo())
-        ),
-        new UpdateOptions().upsert(true)
-    );
-  }
-}

caching/src/main/java/com/iluwatar/caching/LruCache.java

@@ -29,41 +29,83 @@ import java.util.List;
 import java.util.Map;
 import lombok.extern.slf4j.Slf4j;
 
+
 /**
- * Data structure/implementation of the application's cache. The data structure consists of a hash
+ * Data structure/implementation of the application's cache. The data structure
- * table attached with a doubly linked-list. The linked-list helps in capturing and maintaining the
+ * consists of a hash table attached with a doubly linked-list. The linked-list
- * LRU data in the cache. When a data is queried (from the cache), added (to the cache), or updated,
+ * helps in capturing and maintaining the LRU data in the cache. When a data is
- * the data is moved to the front of the list to depict itself as the most-recently-used data. The
+ * queried (from the cache), added (to the cache), or updated, the data is
- * LRU data is always at the end of the list.
+ * moved to the front of the list to depict itself as the most-recently-used
+ * data. The LRU data is always at the end of the list.
  */
 @Slf4j
 public class LruCache {
-
+  /**
+   * Static class Node.
+   */
   static class Node {
-    String userId;
+    /**
-    UserAccount userAccount;
+     * user id.
-    Node previous;
+     */
-    Node next;
+    private final String userId;
+    /**
+     * User Account.
+     */
+    private UserAccount userAccount;
+    /**
+     * previous.
+     */
+    private Node previous;
+    /**
+     * next.
+     */
+    private Node next;
 
-    public Node(String userId, UserAccount userAccount) {
+    /**
-      this.userId = userId;
+     * Node definition.
-      this.userAccount = userAccount;
+     *
+     * @param id      String
+     * @param account {@link UserAccount}
+     */
+    Node(final String id, final UserAccount account) {
+      this.userId = id;
+      this.userAccount = account;
     }
   }
 
-  int capacity;
+  /**
-  Map<String, Node> cache = new HashMap<>();
+   * Capacity of Cache.
-  Node head;
+   */
-  Node end;
+  private int capacity;
+  /**
+   * Cache {@link HashMap}.
+   */
+  private Map<String, Node> cache = new HashMap<>();
+  /**
+   * Head.
+   */
+  private Node head;
+  /**
+   * End.
+   */
+  private Node end;
 
-  public LruCache(int capacity) {
+  /**
-    this.capacity = capacity;
+   * Constructor.
+   *
+   * @param cap Integer.
+   */
+  public LruCache(final int cap) {
+    this.capacity = cap;
   }
 
   /**
    * Get user account.
+   *
+   * @param userId String
+   * @return {@link UserAccount}
    */
-  public UserAccount get(String userId) {
+  public UserAccount get(final String userId) {
     if (cache.containsKey(userId)) {
       var node = cache.get(userId);
       remove(node);
@@ -75,8 +117,10 @@ public class LruCache {
 
   /**
    * Remove node from linked list.
+   *
+   * @param node {@link Node}
    */
-  public void remove(Node node) {
+  public void remove(final Node node) {
     if (node.previous != null) {
       node.previous.next = node.next;
     } else {
@@ -91,8 +135,10 @@ public class LruCache {
 
   /**
    * Move node to the front of the list.
+   *
+   * @param node {@link Node}
    */
-  public void setHead(Node node) {
+  public void setHead(final Node node) {
     node.next = head;
     node.previous = null;
     if (head != null) {
@@ -106,8 +152,11 @@ public class LruCache {
 
   /**
    * Set user account.
+   *
+   * @param userAccount {@link UserAccount}
+   * @param userId      {@link String}
    */
-  public void set(String userId, UserAccount userAccount) {
+  public void set(final String userId, final UserAccount userAccount) {
     if (cache.containsKey(userId)) {
       var old = cache.get(userId);
       old.userAccount = userAccount;
@@ -127,25 +176,43 @@ public class LruCache {
     }
   }
 
-  public boolean contains(String userId) {
+  /**
+   * Check if Cache contains the userId.
+   *
+   * @param userId {@link String}
+   * @return boolean
+   */
+  public boolean contains(final String userId) {
     return cache.containsKey(userId);
   }
 
   /**
    * Invalidate cache for user.
+   *
+   * @param userId {@link String}
    */
-  public void invalidate(String userId) {
+  public void invalidate(final String userId) {
     var toBeRemoved = cache.remove(userId);
     if (toBeRemoved != null) {
-      LOGGER.info("# {} has been updated! Removing older version from cache...", userId);
+      LOGGER.info("# {} has been updated! "
+              + "Removing older version from cache...", userId);
       remove(toBeRemoved);
     }
   }
 
+  /**
+   * Check if the cache is full.
+   * @return boolean
+   */
   public boolean isFull() {
     return cache.size() >= capacity;
   }
 
+  /**
+   * Get LRU data.
+   *
+   * @return {@link UserAccount}
+   */
   public UserAccount getLruData() {
     return end.userAccount;
   }
@@ -161,6 +228,8 @@ public class LruCache {
 
   /**
    * Returns cache data in list form.
+   *
+   * @return {@link List}
    */
   public List<UserAccount> getCacheDataInListForm() {
     var listOfCacheData = new ArrayList<UserAccount>();
@@ -174,10 +243,14 @@ public class LruCache {
 
   /**
    * Set cache capacity.
+   *
+   * @param newCapacity int
    */
-  public void setCapacity(int newCapacity) {
+  public void setCapacity(final int newCapacity) {
     if (capacity > newCapacity) {
-      clear(); // Behavior can be modified to accommodate for decrease in cache size. For now, we'll
+      // Behavior can be modified to accommodate
+      // for decrease in cache size. For now, we'll
+      clear();
       // just clear the cache.
     } else {
       this.capacity = newCapacity;

caching/src/main/java/com/iluwatar/caching/UserAccount.java

@@ -24,19 +24,28 @@
 package com.iluwatar.caching;
 
 import lombok.AllArgsConstructor;
-import lombok.Getter;
+import lombok.Data;
-import lombok.Setter;
+import lombok.EqualsAndHashCode;
 import lombok.ToString;
 
 /**
  * Entity class (stored in cache and DB) used in the application.
  */
-@Setter
+@Data
-@Getter
 @AllArgsConstructor
 @ToString
+@EqualsAndHashCode
 public class UserAccount {
+  /**
+   * User Id.
+   */
   private String userId;
+  /**
+   * User Name.
+   */
   private String userName;
+  /**
+   * Additional Info.
+   */
   private String additionalInfo;
 }

caching/src/main/java/com/iluwatar/caching/constants/CachingConstants.java

@@ -26,11 +26,27 @@ package com.iluwatar.caching.constants;
 /**
  * Constant class for defining constants.
  */
-public class CachingConstants {
+public final class CachingConstants {
-
+  /**
+   * User Account.
+   */
   public static final String USER_ACCOUNT = "user_accounts";
+  /**
+   * User ID.
+   */
   public static final String USER_ID = "userID";
+  /**
+   * User Name.
+   */
   public static final String USER_NAME = "userName";
+  /**
+   * Additional Info.
+   */
   public static final String ADD_INFO = "additionalInfo";
 
+  /**
+   * Constructor.
+   */
+  private CachingConstants() {
+  }
 }

caching/src/main/java/com/iluwatar/caching/constants/package-info.java

@@ -0,0 +1,4 @@
+/**
+ * Constants.
+ */
+package com.iluwatar.caching.constants;

caching/src/main/java/com/iluwatar/caching/database/DbManager.java

@@ -0,0 +1,52 @@
+package com.iluwatar.caching.database;
+
+import com.iluwatar.caching.UserAccount;
+
+/**
+ * <p>DBManager handles the communication with the underlying data store i.e.
+ * Database. It contains the implemented methods for querying, inserting,
+ * and updating data. MongoDB was used as the database for the application.</p>
+ */
+public interface DbManager {
+  /**
+   * Connect to DB.
+   */
+  void connect();
+
+  /**
+   * Disconnect from DB.
+   */
+  void disconnect();
+
+  /**
+   * Read from DB.
+   *
+   * @param userId {@link String}
+   * @return {@link UserAccount}
+   */
+  UserAccount readFromDb(String userId);
+
+  /**
+   * Write to DB.
+   *
+   * @param userAccount {@link UserAccount}
+   * @return {@link UserAccount}
+   */
+  UserAccount writeToDb(UserAccount userAccount);
+
+  /**
+   * Update record.
+   *
+   * @param userAccount {@link UserAccount}
+   * @return {@link UserAccount}
+   */
+  UserAccount updateDb(UserAccount userAccount);
+
+  /**
+   * Update record or Insert if not exists.
+   *
+   * @param userAccount {@link UserAccount}
+   * @return {@link UserAccount}
+   */
+  UserAccount upsertDb(UserAccount userAccount);
+}

caching/src/main/java/com/iluwatar/caching/database/DbManagerFactory.java

@@ -0,0 +1,25 @@
+package com.iluwatar.caching.database;
+
+/**
+ * Creates the database connection accroding the input parameter.
+ */
+public final class DbManagerFactory {
+  /**
+   * Private constructor.
+   */
+  private DbManagerFactory() {
+  }
+
+  /**
+   * Init database.
+   *
+   * @param isMongo boolean
+   * @return {@link DbManager}
+   */
+  public static DbManager initDb(final boolean isMongo) {
+    if (isMongo) {
+      return new MongoDb();
+    }
+    return new VirtualDb();
+  }
+}

caching/src/main/java/com/iluwatar/caching/database/MongoDb.java

@@ -0,0 +1,128 @@
+package com.iluwatar.caching.database;
+
+import static com.iluwatar.caching.constants.CachingConstants.ADD_INFO;
+import static com.iluwatar.caching.constants.CachingConstants.USER_ACCOUNT;
+import static com.iluwatar.caching.constants.CachingConstants.USER_ID;
+import static com.iluwatar.caching.constants.CachingConstants.USER_NAME;
+
+import com.iluwatar.caching.UserAccount;
+import com.iluwatar.caching.constants.CachingConstants;
+import com.mongodb.MongoClient;
+import com.mongodb.MongoClientOptions;
+import com.mongodb.MongoCredential;
+import com.mongodb.ServerAddress;
+import com.mongodb.client.MongoDatabase;
+import com.mongodb.client.model.UpdateOptions;
+import java.util.List;
+import lombok.extern.slf4j.Slf4j;
+import org.bson.Document;
+
+/**
+ * Implementation of DatabaseManager.
+ * implements base methods to work with MongoDb.
+ */
+@Slf4j
+public class MongoDb implements DbManager {
+  private static final String DATABASE_NAME = "admin";
+  private static final String MONGO_USER = "root";
+  private static final String MONGO_PASSWORD = "rootpassword";
+  private MongoClient client;
+  private MongoDatabase db;
+
+  /**
+   * Connect to Db. Check th connection
+   */
+  @Override
+  public void connect() {
+    MongoCredential mongoCredential = MongoCredential.createCredential(MONGO_USER,
+                    DATABASE_NAME,
+                    MONGO_PASSWORD.toCharArray());
+    MongoClientOptions options = MongoClientOptions.builder().build();
+    client = new MongoClient(new ServerAddress(), List.of(mongoCredential), options);
+    db = client.getDatabase(DATABASE_NAME);
+  }
+
+  @Override
+  public void disconnect() {
+    client.close();
+  }
+
+  /**
+   * Read data from DB.
+   *
+   * @param userId {@link String}
+   * @return {@link UserAccount}
+   */
+  @Override
+  public UserAccount readFromDb(final String userId) {
+    var iterable = db
+            .getCollection(CachingConstants.USER_ACCOUNT)
+            .find(new Document(USER_ID, userId));
+    if (iterable.first() == null) {
+      return null;
+    }
+    Document doc = iterable.first();
+    if (doc != null) {
+      String userName = doc.getString(USER_NAME);
+      String appInfo = doc.getString(ADD_INFO);
+      return new UserAccount(userId, userName, appInfo);
+    } else {
+      return null;
+    }
+  }
+
+  /**
+   * Write data to DB.
+   *
+   * @param userAccount {@link UserAccount}
+   * @return {@link UserAccount}
+   */
+  @Override
+  public UserAccount writeToDb(final UserAccount userAccount) {
+    db.getCollection(USER_ACCOUNT).insertOne(
+            new Document(USER_ID, userAccount.getUserId())
+                    .append(USER_NAME, userAccount.getUserName())
+                    .append(ADD_INFO, userAccount.getAdditionalInfo())
+    );
+    return userAccount;
+  }
+
+  /**
+   * Update DB.
+   *
+   * @param userAccount {@link UserAccount}
+   * @return {@link UserAccount}
+   */
+  @Override
+  public UserAccount updateDb(final UserAccount userAccount) {
+    Document id = new Document(USER_ID, userAccount.getUserId());
+    Document dataSet = new Document(USER_NAME, userAccount.getUserName())
+            .append(ADD_INFO, userAccount.getAdditionalInfo());
+    db.getCollection(CachingConstants.USER_ACCOUNT)
+            .updateOne(id, new Document("$set", dataSet));
+    return userAccount;
+  }
+
+  /**
+   * Update data if exists.
+   *
+   * @param userAccount {@link UserAccount}
+   * @return {@link UserAccount}
+   */
+  @Override
+  public UserAccount upsertDb(final UserAccount userAccount) {
+    String userId = userAccount.getUserId();
+    String userName = userAccount.getUserName();
+    String additionalInfo = userAccount.getAdditionalInfo();
+    db.getCollection(CachingConstants.USER_ACCOUNT).updateOne(
+            new Document(USER_ID, userId),
+            new Document("$set",
+                    new Document(USER_ID, userId)
+                            .append(USER_NAME, userName)
+                            .append(ADD_INFO, additionalInfo)
+            ),
+            new UpdateOptions().upsert(true)
+    );
+    return userAccount;
+  }
+}

caching/src/main/java/com/iluwatar/caching/database/VirtualDb.java

@@ -0,0 +1,78 @@
+package com.iluwatar.caching.database;
+
+import com.iluwatar.caching.UserAccount;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Implementation of DatabaseManager.
+ * implements base methods to work with hashMap as database.
+ */
+public class VirtualDb implements DbManager {
+  /**
+   * Virtual DataBase.
+   */
+  private Map<String, UserAccount> db;
+
+  /**
+   * Creates new HashMap.
+   */
+  @Override
+  public void connect() {
+    db = new HashMap<>();
+  }
+
+  @Override
+  public void disconnect() {
+    db = null;
+  }
+
+  /**
+   * Read from Db.
+   *
+   * @param userId {@link String}
+   * @return {@link UserAccount}
+   */
+  @Override
+  public UserAccount readFromDb(final String userId) {
+    if (db.containsKey(userId)) {
+      return db.get(userId);
+    }
+    return null;
+  }
+
+  /**
+   * Write to DB.
+   *
+   * @param userAccount {@link UserAccount}
+   * @return {@link UserAccount}
+   */
+  @Override
+  public UserAccount writeToDb(final UserAccount userAccount) {
+    db.put(userAccount.getUserId(), userAccount);
+    return userAccount;
+  }
+
+  /**
+   * Update reecord in DB.
+   *
+   * @param userAccount {@link UserAccount}
+   * @return {@link UserAccount}
+   */
+  @Override
+  public UserAccount updateDb(final UserAccount userAccount) {
+    return writeToDb(userAccount);
+  }
+
+  /**
+   * Update.
+   *
+   * @param userAccount {@link UserAccount}
+   * @return {@link UserAccount}
+   */
+  @Override
+  public UserAccount upsertDb(final UserAccount userAccount) {
+    return updateDb(userAccount);
+  }
+}

caching/src/main/java/com/iluwatar/caching/database/package-info.java

@@ -0,0 +1,4 @@
+/**
+ * Database classes.
+ */
+package com.iluwatar.caching.database;

caching/src/main/java/com/iluwatar/caching/package-info.java

@@ -0,0 +1,20 @@
+/**
+ * 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.
+ */
+package com.iluwatar.caching;

caching/src/test/java/com/iluwatar/caching/AppTest.java

@@ -25,25 +25,21 @@ package com.iluwatar.caching;
 
 import org.junit.jupiter.api.Test;
 
-import java.io.IOException;
-
 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 
 /**
  * Tests that Caching example runs without errors.
  */
 class AppTest {
-
   /**
    * Issue: Add at least one assertion to this test case.
-   *
+   * <p>
    * Solution: Inserted assertion to check whether the execution of the main method in {@link App}
    * throws an exception.
    */
 
   @Test
   void shouldExecuteApplicationWithoutException() {
-
     assertDoesNotThrow(() -> App.main(new String[]{}));
   }
 }

caching/src/test/java/com/iluwatar/caching/CachingTest.java

@@ -23,11 +23,11 @@
 
 package com.iluwatar.caching;
 
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
 /**
  * Application test
  */
@@ -43,32 +43,30 @@ class CachingTest {
     // to avoid Maven compilation errors. Set flag to true to run the
     // tests with MongoDB (provided that MongoDB is installed and socket
     // connection is open).
-    AppManager.initDb(false);
+    app = new App(false);
-    AppManager.initCacheCapacity(3);
-    app = new App();
   }
 
   @Test
   void testReadAndWriteThroughStrategy() {
-	assertNotNull(app);
+    assertNotNull(app);
     app.useReadAndWriteThroughStrategy();
   }
 
   @Test
   void testReadThroughAndWriteAroundStrategy() {
-	assertNotNull(app);
+    assertNotNull(app);
     app.useReadThroughAndWriteAroundStrategy();
   }
 
   @Test
   void testReadThroughAndWriteBehindStrategy() {
-	assertNotNull(app);
+    assertNotNull(app);
     app.useReadThroughAndWriteBehindStrategy();
   }
 
   @Test
   void testCacheAsideStrategy() {
-	assertNotNull(app);
+    assertNotNull(app);
     app.useCacheAsideStategy();
   }
 }

caching/src/test/java/com/iluwatar/caching/database/MongoDbTest.java

@@ -0,0 +1,84 @@
+package com.iluwatar.caching.database;
+
+import com.iluwatar.caching.UserAccount;
+import com.iluwatar.caching.constants.CachingConstants;
+import com.mongodb.client.FindIterable;
+import com.mongodb.client.MongoCollection;
+import com.mongodb.client.MongoDatabase;
+import org.bson.Document;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mock;
+import org.mockito.internal.util.reflection.Whitebox;
+
+import static com.iluwatar.caching.constants.CachingConstants.ADD_INFO;
+import static com.iluwatar.caching.constants.CachingConstants.USER_ID;
+import static com.iluwatar.caching.constants.CachingConstants.USER_NAME;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.*;
+
+class MongoDbTest {
+  private static final String ID = "123";
+  private static final String NAME = "Some user";
+  private static final String ADDITIONAL_INFO = "Some app Info";
+
+  @Mock
+  MongoDatabase db;
+  private MongoDb mongoDb = new MongoDb();
+
+  private UserAccount userAccount;
+
+  @BeforeEach
+  void init() {
+    db = mock(MongoDatabase.class);
+    Whitebox.setInternalState(mongoDb, "db", db);
+    userAccount = new UserAccount(ID, NAME, ADDITIONAL_INFO);
+
+
+  }
+
+  @Test
+  void connect() {
+    assertDoesNotThrow(() -> mongoDb.connect());
+  }
+
+  @Test
+  void readFromDb() {
+    Document document = new Document(USER_ID, ID)
+            .append(USER_NAME, NAME)
+            .append(ADD_INFO, ADDITIONAL_INFO);
+    MongoCollection<Document> mongoCollection = mock(MongoCollection.class);
+    when(db.getCollection(CachingConstants.USER_ACCOUNT)).thenReturn(mongoCollection);
+
+    FindIterable<Document> findIterable = mock(FindIterable.class);
+    when(mongoCollection.find(any(Document.class))).thenReturn(findIterable);
+
+    when(findIterable.first()).thenReturn(document);
+
+    assertEquals(mongoDb.readFromDb(ID),userAccount);
+  }
+
+  @Test
+  void writeToDb() {
+    MongoCollection<Document> mongoCollection = mock(MongoCollection.class);
+    when(db.getCollection(CachingConstants.USER_ACCOUNT)).thenReturn(mongoCollection);
+    doNothing().when(mongoCollection).insertOne(any(Document.class));
+    assertDoesNotThrow(()-> {mongoDb.writeToDb(userAccount);});
+  }
+
+  @Test
+  void updateDb() {
+    MongoCollection<Document> mongoCollection = mock(MongoCollection.class);
+    when(db.getCollection(CachingConstants.USER_ACCOUNT)).thenReturn(mongoCollection);
+    assertDoesNotThrow(()-> {mongoDb.updateDb(userAccount);});
+  }
+
+  @Test
+  void upsertDb() {
+    MongoCollection<Document> mongoCollection = mock(MongoCollection.class);
+    when(db.getCollection(CachingConstants.USER_ACCOUNT)).thenReturn(mongoCollection);
+    assertDoesNotThrow(()-> {mongoDb.upsertDb(userAccount);});
+  }
+}

callback/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Callback
-folder: callback
+category: Idiom
-permalink: /patterns/callback/
-categories: Idiom
 language: en
 tags:
  - Reactive

chain-of-responsibility/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Chain of responsibility
-folder: chain-of-responsibility
+category: Behavioral
-permalink: /patterns/chain-of-responsibility/
-categories: Behavioral
 language: en
 tags:
  - Gang of Four

circuit-breaker/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Circuit Breaker
-folder: circuit-breaker
+category: Behavioral
-permalink: /patterns/circuit-breaker/
-categories: Behavioral
 language: en
 tags:
   - Performance

cloud-static-content-hosting/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Static Content Hosting
-folder: cloud-static-content-hosting
+category: Cloud
-permalink: /patterns/cloud-static-content-hosting/
-categories: Cloud
 language: en
 tags:
 - Cloud distributed

collection-pipeline/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Collection Pipeline
-folder: collection-pipeline
+category: Functional
-permalink: /patterns/collection-pipeline/
-categories: Functional
 language: en
 tags:
  - Reactive

combinator/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Combinator
-folder: combinator
+category: Idiom
-permalink: /patterns/combinator/
-categories: Idiom
 language: en
 tags:
  - Reactive

command/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Command
-folder: command
+category: Behavioral
-permalink: /patterns/command/
-categories: Behavioral
 language: en
 tags:
  - Gang of Four

commander/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Commander
-folder: commander
+category: Concurrency
-permalink: /patterns/commander/
-categories: Concurrency
 language: en
 tags:
  - Cloud distributed

composite-entity/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Composite Entity
-folder: composite-entity
+category: Structural
-permalink: /patterns/composite-entity/
-categories: Structural
 language: en
 tags:
  - Enterprise Integration Pattern

composite/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Composite
-folder: composite
+category: Structural
-permalink: /patterns/composite/
-categories: Structural
 language: en
 tags:
  - Gang of Four

converter/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Converter
-folder: converter
+category: Creational
-permalink: /patterns/converter/
-categories: Creational
 language: en
 tags:
  - Decoupling

cqrs/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: CQRS
-folder: cqrs
+category: Architectural
-permalink: /patterns/cqrs/
-categories: Architectural
 language: en
 tags:
   - Performance

dao/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Data Access Object
-folder: dao
+category: Architectural
-permalink: /patterns/dao/
-categories: Architectural
 language: en
 tags:
  - Data access

data-bus/README.md

@@ -1,10 +1,6 @@
 ---
-layout: pattern
 title: Data Bus
-folder: data-bus
+category: Architectural
-permalink: /patterns/data-bus/
-
-categories: Architectural
 language: en
 tags:
  - Decoupling

data-locality/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Data Locality
-folder: data-locality
+category: Behavioral
-permalink: /patterns/data-locality/
-categories: Behavioral
 language: en
 tags:
  - Game programming

data-mapper/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Data Mapper
-folder: data-mapper
+category: Architectural
-permalink: /patterns/data-mapper/
-categories: Architectural
 language: en
 tags:
  - Decoupling

data-transfer-object/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Data Transfer Object
-folder: data-transfer-object
+category: Architectural
-permalink: /patterns/data-transfer-object/
-categories: Architectural
 language: en
 tags:
  - Performance

decorator/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Decorator
-folder: decorator
+category: Structural
-permalink: /patterns/decorator/
-categories: Structural
 language: en
 tags:
  - Gang of Four

delegation/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Delegation
-folder: delegation
+category: Structural
-permalink: /patterns/delegation/
-categories: Structural
 language: en
 tags:
  - Decoupling

dependency-injection/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Dependency Injection
-folder: dependency-injection
+category: Creational
-permalink: /patterns/dependency-injection/
-categories: Creational
 language: en
 tags:
  - Decoupling

dirty-flag/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Dirty Flag
-folder: dirty-flag
+category: Behavioral
-permalink: /patterns/dirty-flag/
-categories: Behavioral
 language: en
 tags:
  - Game programming

domain-model/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Domain Model
-folder: domain-model
+category: Architectural
-permalink: /patterns/domain-model/
-categories: Architectural
 language: en
 tags:
  - Domain

double-buffer/README.md

@@ -1,9 +1,6 @@
 ---  
-layout: pattern  
 title: Double Buffer 
-folder:  double-buffer  
+category: Behavioral
-permalink: /patterns/double-buffer/  
-categories: Behavioral
 language: en
 tags:  
  - Performance

double-checked-locking/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Double Checked Locking
-folder: double-checked-locking
+category: Idiom
-permalink: /patterns/double-checked-locking/
-categories: Idiom
 language: en
 tags:
  - Performance

double-dispatch/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Double Dispatch
-folder: double-dispatch
+category: Idiom
-permalink: /patterns/double-dispatch/
-categories: Idiom
 language: en
 tags:
  - Extensibility

eip-aggregator/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: EIP Aggregator
-folder: eip-aggregator
+category: Integration
-permalink: /patterns/eip-aggregator/
-categories: Integration
 language: en
 tags:
  - Enterprise Integration Pattern

eip-message-channel/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: EIP Message Channel
-folder: eip-message-channel
+category: Integration
-permalink: /patterns/eip-message-channel/
-categories: Integration
 language: en
 tags:
  - Enterprise Integration Pattern

eip-publish-subscribe/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: EIP Publish Subscribe
-folder: eip-publish-subscribe
+category: Integration
-permalink: /patterns/eip-publish-subscribe/
-categories: Integration
 language: en
 tags:
  - Enterprise Integration Pattern

eip-splitter/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: EIP Splitter
-folder: eip-splitter
+category: Integration
-permalink: /patterns/eip-splitter/
-categories: Integration
 language: en
 tags:
  - Enterprise Integration Pattern

eip-wire-tap/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: EIP Wire Tap
-folder: eip-wire-tap
+category: Integration
-permalink: /patterns/eip-wire-tap/
-categories: Integration
 language: en
 tags:
  - Enterprise Integration Pattern

event-aggregator/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Event Aggregator
-folder: event-aggregator
+category: Structural
-permalink: /patterns/event-aggregator/
-categories: Structural
 language: en
 tags:
  - Reactive

event-asynchronous/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Event-based Asynchronous
-folder: event-asynchronous
+category: Concurrency
-permalink: /patterns/event-asynchronous/
-categories: Concurrency
 language: en
 tags:
  - Reactive

event-driven-architecture/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Event Driven Architecture
-folder: event-driven-architecture
+category: Architectural
-permalink: /patterns/event-driven-architecture/
-categories: Architectural
 language: en
 tags:
  - Reactive

event-queue/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Event Queue
-folder: event-queue
+category: Concurrency
-permalink: /patterns/event-queue/
-categories: Concurrency
 language: en
 tags:
  - Game programming

event-sourcing/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Event Sourcing
-folder: event-sourcing
+category: Architectural
-permalink: /patterns/event-sourcing/
-categories: Architectural
 language: en
 tags:
   - Performance

execute-around/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Execute Around
-folder: execute-around
+category: Idiom
-permalink: /patterns/execute-around/
-categories: Idiom
 language: en
 tags:
  - Extensibility

extension-objects/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Extension objects
-folder: extension-objects
+category: Behavioral
-permalink: /patterns/extension-objects/
-categories: Behavioral
 language: en
 tags:
  - Extensibility

facade/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Facade
-folder: facade
+category: Structural
-permalink: /patterns/facade/
-categories: Structural
 language: en
 tags:
  - Gang Of Four

factory-kit/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Factory Kit
-folder: factory-kit
+category: Creational
-permalink: /patterns/factory-kit/
-categories: Creational
 language: en
 tags:
  - Extensibility

factory-method/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Factory Method
-folder: factory-method
+category: Creational
-permalink: /patterns/factory-method/
-categories: Creational
 language: en
 tags:
  - Extensibility

factory/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Factory
-folder: factory
+category: Creational
-permalink: /patterns/factory/
-categories: Creational
 language: en
 tags:
  - Gang of Four

fanout-fanin/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Fan-Out/Fan-In
-folder: fanout-fanin
+category: Integration
-permalink: /patterns/fanout-fanin/
-categories: Integration
 language: en
 tags:
 - Microservices

feature-toggle/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Feature Toggle
-folder: feature-toggle
+category: Behavioral
-permalink: /patterns/feature-toggle/
-categories: Behavioral
 language: en
 tags:
  - Extensibility

filterer/README.md

@@ -1,12 +1,8 @@
 ---
-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
 language: en
-categories:
+category: Functional
- - Functional
 tags:
  - Extensibility
 ---

fluentinterface/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Fluent Interface
-folder: fluentinterface
+category: Functional
-permalink: /patterns/fluentinterface/
-categories: Functional
 language: en
 tags: 
  - Reactive

flux/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Flux
-folder: flux
+category: Structural
-permalink: /patterns/flux/
-categories: Structural
 language: en
 tags:
  - Decoupling

flyweight/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Flyweight
-folder: flyweight
+category: Structural
-permalink: /patterns/flyweight/
-categories: Structural
 language: en
 tags:
  - Gang of Four

front-controller/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Front Controller
-folder: front-controller
+category: Structural
-permalink: /patterns/front-controller/
-categories: Structural
 language: en
 tags:
  - Decoupling

game-loop/README.md

@@ -1,9 +1,6 @@
 ---  
-layout: pattern  
 title: Game Loop 
-folder:  game-loop  
+category: Behavioral
-permalink: /patterns/game-loop/  
-categories: Behavioral
 language: en
 tags:  
  - Game programming

guarded-suspension/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Guarded Suspension
-folder: guarded-suspension
+category: Concurrency
-permalink: /patterns/guarded-suspension/
-categories: Concurrency
 language: en
 tags:
  - Decoupling

half-sync-half-async/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Half-Sync/Half-Async
-folder: half-sync-half-async
+category: Concurrency
-permalink: /patterns/half-sync-half-async/
-categories: Concurrency
 language: en
 tags:
  - Performance

hexagonal/README.md

@@ -1,10 +1,6 @@
 ---
-layout: pattern
 title: Hexagonal Architecture
-folder: hexagonal
+category: Architectural
-permalink: /patterns/hexagonal/
-pumlformat: svg
-categories: Architectural
 language: en
 tags:
  - Decoupling

index.md

@@ -0,0 +1,147 @@
+| Pattern                                                                              | Category               | Tags                              |
+| :---                                                                                 | :---                   | :---                              |
+| [Abstract Document](abstract-document)                                               | Structural             | Extensibility                     |
+| [Abstract Factory](abstract-factory)                                                 | Creational             | Gang of Four                      |
+| [Active Object](active-object)                                                       | Concurrency            | Performance                       |
+| [Acyclic Visitor](acyclic-visitor)                                                   | Behavioral             | Extensibility                     |
+| [Adapter](adapter)                                                                   | Structural             | Gang of Four                      |
+| [Aggregator Microservices](aggregator-microservices)                                 | Architectural          | Cloud distributed                 |
+| [Ambassador](ambassador)                                                             | Structural             | Decoupling                        |
+| [API Gateway](api-gateway)                                                           | Architectural          | Cloud distributed, Decoupling     |
+| [Arrange/Act/Assert](arrange-act-assert)                                             | Idiom                  | Testing                           |
+| [Async Method Invocation](async-method-invocation)                                   | Concurrency            | Reactive                          |
+| [Balking](balking)                                                                   | Concurrency            | Decoupling                        |
+| [Bridge](bridge)                                                                     | Structural             | Gang of Four                      |
+| [Builder](builder)                                                                   | Creational             | Gang of Four                      |
+| [Business Delegate](business-delegate)                                               | Structural             | Decoupling                        |
+| [Bytecode](bytecode)                                                                 | Behavioral             | Game programming                  |
+| [Caching](caching)                                                                   | Behavioral             | Performance                       |
+| [Callback](callback)                                                                 | Idiom                  | Reactive                          |
+| [Chain of Responsibility](chain-of-responsibility)                                   | Behavioral             | Gang of Four                      |
+| [Circuit Breaker](circuit-breaker)                                                   | Behavioral             | Performance, Decoupling           |
+| [Cloud Static Content Hosting](cloud-static-content-hosting)                         | Cloud                  | Cloud distributed                 |
+| [Collection Pipeline](collection-pipeline)                                           | Functional             | Reactive                          |
+| [Combinator](combinator)                                                             | Idiom                  | Reactive                          |
+| [Command](command)                                                                   | Behavioral             | Gang of Four                      |
+| [Commander](commander)                                                               | Concurrency            | Cloud distributed                 |
+| [Composite](composite)                                                               | Structural             | Gang of Four                      |
+| [Composite Entity](composite-entity)                                                 | Structural             | Enterprise Integration Pattern    |
+| [Converter](converter)                                                               | Creational             | Decoupling                        |
+| [Command Query Responsibility Segregation](command-query-responsibility-segregation) | Architectural          | Performance, Cloud distributed    |
+| [Data Access Object](data-access-object)                                             | Architectural          | Data access                       |
+| [Data Bus](data-bus)                                                                 | Architectural          | Decoupling                        |
+| [Data Locality](data-locality)                                                       | Behavioral             | Performance, Game programming     |
+| [Data Mapper](data-mapper)                                                           | Architectural          | Decoupling                        |
+| [Data Transfer Object](data-transfer-object)                                         | Architectural          | Performance                       |
+| [Decorator](decorator)                                                               | Structural             | Gang of Four, Extensibility       |
+| [Delegation](delegation)                                                             | Structural             | Decoupling                        |
+| [Dependency Injection](dependency-injection)                                         | Creational             | Decoupling                        |
+| [Dirty Flag](dirty-flag)                                                             | Behavioral             | Performance, Game programming     |
+| [Double Buffer](double-buffer)                                                       | Behavioral             | Performance, Game programming     |
+| [Double Checked Locking](double-checked-locking)                                     | Idiom                  | Performance                       |
+| [Double Dispatch](double-dispatch)                                                   | Idiom                  | Extensibility                     |
+| [EIP Aggregator](eip-aggregator)                                                     | Integration            | Enterprise Integration Pattern    |
+| [EIP Message Channel](eip-message-channel)                                           | Integration            | Enterprise Integration Pattern    |
+| [EIP Publish and Subscribe](eip-publish-and-subscribe)                               | Integration            | Enterprise Integration Pattern    |
+| [EIP Splitter](eip-splitter)                                                         | Integration            | Enterprise Integration Pattern    |
+| [EIP Wire Tap](eip-wire-tap)                                                         | Integration            | Enterprise Integration Pattern    |
+| [Event Aggregator](event-aggregator)                                                 | Structural             | Reactive                          |
+| [Event Based Asynchronous](event-based-asynchronous)                                 | Concurrency            | Reactive                          |
+| [Event Driven Architecture](event-driven-architecture)                               | Architectural          | Reactive                          |
+| [Event Queue](event-queue)                                                           | Concurrency            | Game programming                  |
+| [Event Sourcing](event-sourcing)                                                     | Architectural          | Performance                       |
+| [Execute Around](execute-around)                                                     | Idiom                  | Extensibility                     |
+| [Extension Objects](extension-objects)                                               | Behavioral             | Extensibility                     |
+| [Facade](facade)                                                                     | Structural             | Gang of Four, Decoupling          |
+| [Factory](factory)                                                                   | Creational             | Gang of Four                      |
+| [Factory kit](factory-kit)                                                           | Creational             | Extensibility                     |
+| [Factory Method](factory-method)                                                     | Creational             | Gang of Four, Extensibility       |
+| [Fan-Out/Fan-In](fanout-fanin)                                                       | Integration            | Microservices                     |
+| [Feature Toggle](feature-toggle)                                                     | Behavioral             | Extensibility                     |
+| [Filterer](filterer)                                                                 | Functional             | Extensibility                     |
+| [Fluent Interface](fluent-interface)                                                 | Functional             | Reactive                          |
+| [Flux](flux)                                                                         | Structural             | Decoupling                        |
+| [Flyweight](flyweight)                                                               | Structural             | Gang of Four, Performance         |
+| [Front Controller](front-controller)                                                 | Structural             | Decoupling                        |
+| [Game Loop](game-loop)                                                               | Behavioral             | Game programming                  |
+| [Guarded Suspension](guarded-suspension)                                             | Concurrency            | Decoupling                        |
+| [Half-Sync Half-Async](half-sync-half-async)                                         | Concurrency            | Performance                       |
+| [Hexagonal](hexagonal)                                                               | Architectural          | Decoupling                        |
+| [Intercepting Filter](intercepting-filter)                                           | Behavioral             | Decoupling                        |
+| [Interpreter](interpreter)                                                           | Behavioral             | Gang of Four                      |
+| [Iterator](iterator)                                                                 | Behavioral             | Gang of Four                      |
+| [Layers](layers)                                                                     | Architectural          | Decoupling                        |
+| [Lazy Loading](lazy-loading)                                                         | Idiom                  | Performance                       |
+| [Leader Election](leader-election)                                                   | Behavioral             | Cloud distributed                 |
+| [Leader Followers](leader-followers)                                                 | Concurrency            | Performance                       |
+| [Lockable Object](lockable-object)                                                   | Concurrency            | Performance                       |
+| [Marker Interface](marker-interface)                                                 | Structural             | Decoupling                        |
+| [Master Worker](master-worker)                                                       | Concurrency            | Performance                       |
+| [Mediator](mediator)                                                                 | Behavioral             | Gang of Four, Decoupling          |
+| [Memento](memento)                                                                   | Behavioral             | Gang of Four                      |
+| [Model View Controller](model-view-controller)                                       | Architectural          | Decoupling                        |
+| [Model View Presenter](model-view-presenter)                                         | Architectural          | Decoupling                        |
+| [Model View ViewModel](model-view-viewmodel)                                         | Architectural          | Decoupling                        |
+| [Module](module)                                                                     | Structural             | Decoupling                        |
+| [Monad](monad)                                                                       | Functional             | Reactive                          |
+| [Monostate](monostate)                                                               | Creational             | Instantiation                     |
+| [Multiton](multiton)                                                                 | Creational             | Instantiation                     |
+| [Mute Idiom](mute-idiom)                                                             | Idiom                  | Decoupling                        |
+| [Naked Objects](naked-objects)                                                       | Architectural          | Decoupling                        |
+| [Null Object](null-object)                                                           | Behavioral             | Extensibility                     |
+| [Object Mother](object-mother)                                                       | Creational             | Instantiation                     |
+| [Object Pool](object-pool)                                                           | Creational             | Performance, Game programming     |
+| [Observer](observer)                                                                 | Behavioral             | Gang of Four, Reactive            |
+| [Page Object](page-object)                                                           | Structural             | Decoupling                        |
+| [Parameter Object](parameter-object)                                                 | Behavioral             | Extensibility                     |
+| [Partial Response](partial-response)                                                 | Behavioral             | Decoupling                        |
+| [Pipeline](pipeline)                                                                 | Behavioral             | Decoupling                        |
+| [Poison Pill](poison-pill)                                                           | Behavioral             | Cloud distributed, Reactive       |
+| [Presentation Model](presentation-model)                                             | Behavioral             | Decoupling                        |
+| [Priority Queue](priority-queue)                                                     | Behavioral             | Decoupling                        |
+| [Private Class Data](private-class-data)                                             | Idiom                  | Data access                       |
+| [Producer Consumer](producer-consumer)                                               | Concurrency            | Reactive                          |
+| [Promise](promise)                                                                   | Concurrency            | Reactive                          |
+| [Property](property)                                                                 | Creational             | Instantiation                     |
+| [Prototype](prototype)                                                               | Creational             | Gang of Four, Instantiation       |
+| [Proxy](proxy)                                                                       | Structural             | Gang of Four, Decoupling          |
+| [Queue Based Load Leveling](queue-based-load-leveling)                               | Concurrency            | Performance, Decoupling           |
+| [Reactor](reactor)                                                                   | Concurrency            | Performance, Reactive             |
+| [Reader Writer Lock](reader-writer-lock)                                             | Concurrency            | Performance                       |
+| [Registry](registry)                                                                 | Creational             | Instantiation                     |
+| [Repository](repository)                                                             | Architectural          | Data access                       |
+| [Resource Acquisition Is Initialization](resource-acquisition-is-initialization)     | Idiom                  | Data access                       |
+| [Retry](retry)                                                                       | Behavioral             | Performance                       |
+| [Role Object](role-object)                                                           | Structural             | Extensibility                     |
+| [Saga](saga)                                                                         | Concurrency            | Cloud distributed                 |
+| [Semaphore](semaphore)                                                               | Concurrency            | Performance                       |
+| [Separated Interface](separated-interface)                                           | Structural             | Decoupling                        |
+| [Servant](servant)                                                                   | Behavioral             | Decoupling                        |
+| [Serverless](serverless)                                                             | Architectural          | Cloud distributed                 |
+| [Service Layer](service-layer)                                                       | Architectural          | Data access                       |
+| [Service Locator](service-locator)                                                   | Architectural          | Performance, Game programming     |
+| [Sharding](sharding)                                                                 | Behavioral             | Performance, Cloud distributed    |
+| [Singleton](singleton)                                                               | Creational             | Gang of Four                      |
+| [Spatial Partition](spatial-partition)                                               | Behavioral             | Performance, Game programming     |
+| [Special Case](special-case)                                                         | Behavioral             | Extensibility                     |
+| [Specification](specification)                                                       | Behavioral             | Data access                       |
+| [State](state)                                                                       | Behavioral             | Gang of Four                      |
+| [Step Builder](step-builder)                                                         | Creational             | Instantiation                     |
+| [Strangler](strangler)                                                               | Structural             | Cloud distributed, Extensibility  |
+| [Strategy](strategy)                                                                 | Behavioral             | Gang of Four                      |
+| [Subclass Sandbox](subclass-sandbox)                                                 | Behavioral             | Game programming                  |
+| [Table Module](table-module)                                                         | Structural             | Data access                       |
+| [Template Method](table-module)                                                      | Behavioral             | Gang of Four                      |
+| [Thread Pool](thread-pool)                                                           | Concurrency            | Performance                       |
+| [Throttling](throttling)                                                             | Behavioral             | Performance                       |
+| [Thread Local Storage](thread-local-storage)                                         | Idiom                  | Performance                       |
+| [Tolerant Reader](tolerant-reader)                                                   | Integration            | Decoupling                        |
+| [Trampoline](trampoline)                                                             | Behavioral             | Performance                       |
+| [Transaction Script](transaction-script)                                             | Behavioral             | Data access                       |
+| [Twin](twin)                                                                         | Structural             | Extensibility                     |
+| [Type Object](type-object)                                                           | Behavioral             | Game programming, Extensibility   |
+| [Unit of Work](unit-of-work)                                                         | Architectural          | Data access                       |
+| [Update Method](update-method)                                                       | Behavioral             | Game programming                  |
+| [Value Object](value-object)                                                         | Creational             | Instantiation                     |
+| [Version Number](version-number)                                                     | Concurrency            | Data access, Microservices        |
+| [Visitor](visitor)                                                                   | Behavioral             | Gang of Four                      |

intercepting-filter/README.md

@@ -1,8 +1,5 @@
 ---
-layout: pattern
 title: Intercepting Filter
-folder: intercepting-filter
-permalink: /patterns/intercepting-filter/
 categories: Behavioral
 language: en
 tags:

interpreter/README.md

@@ -1,8 +1,5 @@
 ---
-layout: pattern
 title: Interpreter
-folder: interpreter
-permalink: /patterns/interpreter/
 categories: Behavioral
 language: en
 tags:

iterator/README.md

@@ -1,8 +1,5 @@
 ---
-layout: pattern
 title: Iterator
-folder: iterator
-permalink: /patterns/iterator/
 categories: Behavioral
 language: en
 tags:

layers/README.md

@@ -1,10 +1,6 @@
 ---
-layout: pattern
 title: Layers
-folder: layers
+category: Architectural
-permalink: /patterns/layers/
-pumlformat: svg
-categories: Architectural
 language: en
 tags:
  - Decoupling

lazy-loading/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Lazy Loading
-folder: lazy-loading
+category: Idiom
-permalink: /patterns/lazy-loading/
-categories: Idiom
 language: en
 tags:
  - Performance

leader-election/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Leader Election
-folder: leader-election
+category: Behavioral
-permalink: /patterns/leader-election/
-categories: Behavioral
 language: en
 tags:
  - Cloud distributed

leader-followers/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Leader/Followers
-folder: leader-followers
+category: Concurrency
-permalink: /patterns/leader-followers/
-categories: Concurrency
 language: en
 tags:
  - Performance

localization/ko/adapter/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Adapter
-folder: adapter
+category: Structural
-permalink: /patterns/adapter/ko
-categories: Structural
 language: ko
 tags:
 - Gang of Four
@@ -96,7 +93,7 @@ captain.row();
 
 ## 클레스 다이어그램
 
-![alt text](https://github.com/warp125/java-design-patterns/blob/master/adapter/etc/adapter.urm.png?raw=true)
+![alt text](etc/adapter.urm.png)
 
 ## 적용 가능성
 

localization/ko/factory/README.md

@@ -1,9 +1,6 @@
 ---
-layout: pattern
 title: Factory
-folder: factory
+category: Creational
-permalink: /patterns/factory/ko
-categories: Creational
 language: ko
 tags:
 - Gang of Four
@@ -107,7 +104,7 @@ This Ferrari.
 
 ## 클래스 다이어그램
 
-![alt text](https://github.com/iluwatar/java-design-patterns/blob/master/factory/etc/factory.urm.png)
+![alt text](etc/factory.urm.png)
 
 ## 적용 가능성