Dirty Flag pattern #560

dirty-flag/pom.xml

@@ -0,0 +1,26 @@
+<?xml version="1.0"?>
+<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <modelVersion>4.0.0</modelVersion>
+  <parent>
+    <groupId>com.iluwatar</groupId>
+    <artifactId>java-design-patterns</artifactId>
+    <version>1.19.0-SNAPSHOT</version>
+  </parent>
+  <groupId>com.iluwatar</groupId>
+  <artifactId>dirty-flag</artifactId>
+  <version>1.19.0-SNAPSHOT</version>
+  <name>dirty-flag</name>
+  <url>http://maven.apache.org</url>
+  <properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+  </properties>
+  <dependencies>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>3.8.1</version>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+</project>

dirty-flag/src/main/java/com/iluwatar/dirtyflag/App.java

@@ -0,0 +1,88 @@
+/**
+ * The MIT License
+ * Copyright (c) 2014-2016 Ilkka Seppälä
+ * <p>
+ * 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:
+ * <p>
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * <p>
+ * 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.dirtyflag;
+
+import java.util.List;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ *
+ * This application demonstrates the <b>Dirty Flag</b> pattern. The dirty flag behavioral pattern allows you to avoid
+ * expensive operations that would just need to be done again anyway. This is a simple pattern that really just explains
+ * how to add a bool value to your class that you can set anytime a property changes. This will let your class know that
+ * any results it may have previously calculated will need to be calculated again when they’re requested. Once the
+ * results are re-calculated, then the bool value can be cleared.
+ * 
+ * There are some points that need to be considered before diving into using this pattern:- there are some things you’ll
+ * need to consider:- (1) Do you need it? This design pattern works well when the results to be calculated are difficult
+ * or resource intensive to compute. You want to save them. You also don’t want to be calculating them several times in
+ * a row when only the last one counts. (2) When do you set the dirty flag? Make sure that you set the dirty flag within
+ * the class itself whenever an important property changes. This property should affect the result of the calculated
+ * result and by changing the property, that makes the last result invalid. (3) When do you clear the dirty flag? It
+ * might seem obvious that the dirty flag should be cleared whenever the result is calculated with up-to-date
+ * information but there are other times when you might want to clear the flag.
+ *
+ * In this example, the {@link DataFetcher} holds the <i>dirty flag</i>. It fetches and re-fetches from <i>world.txt</i>
+ * when needed. {@link World} mainly serves the data to the front-end.
+ */
+public class App {
+
+  private static final Logger LOGGER = LoggerFactory.getLogger(App.class);
+
+  /**
+   * Program execution point
+   */
+  public void run() {
+
+    final ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor();
+    executorService.scheduleAtFixedRate(new Runnable() {
+      @Override
+      public void run() {
+        World world = World.getInstance();
+        List<String> countries = world.fetch();
+        System.out.println("Our world currently has the following countries:-");
+        for (String country : countries) {
+          System.out.println("\t" + country);
+        }
+      }
+    }, 0, 15, TimeUnit.SECONDS); // Run at every 15 seconds.
+  }
+
+  /**
+   * Program entry point
+   *
+   * @param args
+   *          command line args
+   */
+  public static void main(String[] args) {
+    App app = new App();
+
+    app.run();
+  }
+
+}

dirty-flag/src/main/java/com/iluwatar/dirtyflag/DataFetcher.java

@@ -0,0 +1,71 @@
+package com.iluwatar.dirtyflag;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * A mock database manager -- Fetches data from a raw file.
+ * 
+ * @author swaisuan
+ *
+ */
+public class DataFetcher {
+
+  private static DataFetcher df;
+  private final String filename = "world.txt";
+  private long lastFetched = -1;
+
+  private DataFetcher() {
+  }
+
+  /**
+   * Init.
+   * 
+   * @return DataFetcher instance
+   */
+  public static DataFetcher getInstance() {
+    if (df == null) {
+      df = new DataFetcher();
+    }
+    return df;
+  }
+
+  private boolean isDirty(long fileLastModified) {
+    if (lastFetched != fileLastModified) {
+      lastFetched = fileLastModified;
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Fetches data/content from raw file.
+   * 
+   * @return List of strings
+   */
+  public List<String> fetch() {
+    ClassLoader classLoader = getClass().getClassLoader();
+    File file = new File(classLoader.getResource(filename).getFile());
+
+    if (isDirty(file.lastModified())) {
+      System.out.println(filename + " is dirty! Re-fetching file content...");
+
+      List<String> data = new ArrayList<String>();
+      try (BufferedReader br = new BufferedReader(new FileReader(file))) {
+        String line;
+        while ((line = br.readLine()) != null) {
+          data.add(line);
+        }
+      } catch (IOException e) {
+        e.printStackTrace();
+      }
+      return data;
+    }
+
+    return null;
+  }
+}

dirty-flag/src/main/java/com/iluwatar/dirtyflag/World.java

@@ -0,0 +1,47 @@
+package com.iluwatar.dirtyflag;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 
+ * A middle-layer app that calls/passes along data from the back-end.
+ * 
+ * @author swaisuan
+ *
+ */
+public class World {
+
+  private static World world;
+  private static List<String> countries = new ArrayList<String>();
+
+  private World() {
+  }
+
+  /**
+   * Init.
+   * 
+   * @return World instance
+   */
+  public static World getInstance() {
+    if (world == null) {
+      world = new World();
+    }
+    return world;
+  }
+
+  /**
+   * 
+   * Calls {@link DataFetcher} to fetch data from back-end.
+   * 
+   * @return List of strings
+   */
+  public List<String> fetch() {
+    DataFetcher df = DataFetcher.getInstance();
+    List<String> data = df.fetch();
+
+    countries = data == null ? countries : data;
+
+    return countries;
+  }
+}

dirty-flag/src/main/resources/world.txt

@@ -0,0 +1,3 @@
+UNITED_KINGDOM
+MALAYSIA
+UNITED_STATES

dirty-flag/src/test/java/org/dirty/flag/AppTest.java

@@ -0,0 +1,40 @@
+/**
+ * The MIT License
+ * Copyright (c) 2014-2016 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 org.dirty.flag;
+
+import java.io.IOException;
+
+import org.junit.Test;
+
+import com.iluwatar.dirtyflag.App;
+
+/**
+ * Tests that Dirty-Flag example runs without errors.
+ */
+public class AppTest {
+  @Test
+  public void test() throws IOException {
+    String[] args = {};
+    App.main(args);
+  }
+}

dirty-flag/src/test/java/org/dirty/flag/DirtyFlagTest.java

@@ -0,0 +1,63 @@
+/**
+ * The MIT License
+ * Copyright (c) 2014-2016 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 org.dirty.flag;
+
+import static org.junit.Assert.assertTrue;
+
+import java.lang.reflect.Field;
+import java.util.List;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import com.iluwatar.dirtyflag.DataFetcher;
+
+/**
+ *
+ * Application test
+ *
+ */
+public class DirtyFlagTest {
+
+  @Before
+  public void reset() throws SecurityException, NoSuchFieldException, IllegalArgumentException, IllegalAccessException {
+    Field instance = DataFetcher.class.getDeclaredField("df");
+    instance.setAccessible(true);
+    instance.set(null, null);
+  }
+
+  @Test
+  public void testIsDirty() {
+    DataFetcher df = DataFetcher.getInstance();
+    List<String> countries = df.fetch();
+    assertTrue(!countries.isEmpty());
+  }
+
+  @Test
+  public void testIsNotDirty() {
+    DataFetcher df = DataFetcher.getInstance();
+    df.fetch();
+    List<String> countries = df.fetch();
+    assertTrue(countries == null);
+  }
+}

pom.xml

@@ -154,7 +154,8 @@
         <module>eip-splitter</module>
         <module>eip-aggregator</module>
         <module>retry</module>
-    </modules>
+    	<module>dirty-flag</module>
+  </modules>
 
     <repositories>
         <repository>