updated

Author: Chaklader Asfak Arefe

.DS_Store

@@ -0,0 +1,75 @@
+package com.javacodegeeks.patterns.templatepattern;
+
+import java.util.Date;
+
+public abstract class ConnectionTemplate {
+	
+	private boolean isLoggingEnable = true;
+	
+	public ConnectionTemplate(){
+		isLoggingEnable = disableLogging();
+	}
+	
+	public final void run(){
+		
+		setDBDriver();
+		logging("Drivers set ["+new Date()+"]");
+		
+		setCredentials();
+		logging("Credentails set ["+new Date()+"]");
+		
+		connect();
+		logging("Conencted");
+		
+		prepareStatement();
+		logging("Statement prepared ["+new Date()+"]");
+		
+		setData();
+		logging("Data set ["+new Date()+"]");
+		
+		insert();
+		logging("Inserted ["+new Date()+"]");
+		
+		close();
+		logging("Conenctions closed ["+new Date()+"]");
+		
+		destroy();
+		logging("Object destoryed ["+new Date()+"]");		
+	}
+	
+	public abstract void setDBDriver();
+
+	public abstract void setCredentials(); 
+
+	public void connect(){
+		System.out.println("Setting connection...");
+	}
+	
+	public void prepareStatement(){
+		System.out.println("Preparing insert statement...");
+	}
+	
+	public abstract void setData();
+	
+	public void insert(){
+		System.out.println("Inserting data...");
+	}
+	
+	public void close(){
+		System.out.println("Closing connections...");
+	}
+
+	public void destroy(){
+		System.out.println("Destroying connection objects...");
+	}
+	
+	public boolean disableLogging(){
+		return true;
+	}
+	
+	private void logging(String msg){
+		if(isLoggingEnable){
+			System.out.println("Logging....: "+msg);
+		}
+	}
+}

Design_Patterns_00/.DS_Store

@@ -0,0 +1,25 @@
+package com.javacodegeeks.patterns.templatepattern;
+
+public class MySqLCSVCon extends ConnectionTemplate{
+
+	@Override
+	public void setDBDriver() {
+		System.out.println("Setting MySQL DB drivers...");
+	}
+	
+	@Override
+	public void setCredentials() {
+		System.out.println("Setting credentials for MySQL DB...");
+	}
+
+	@Override
+	public void setData() {
+		System.out.println("Setting up data from csv file....");
+	}
+
+	@Override
+	public boolean disableLogging() {
+		return false;
+	}
+
+}

Design_Patterns_00/Template/.DS_Store

@@ -0,0 +1,21 @@
+package com.javacodegeeks.patterns.templatepattern;
+
+public class OracleTxtCon extends ConnectionTemplate{
+	
+	@Override
+	public void setDBDriver() {
+		System.out.println("Setting Oracle DB drivers...");
+	}
+
+	@Override
+	public void setCredentials() {
+		System.out.println("Setting credentials for Oracle DB...");
+	}
+	
+	@Override
+	public void setData() {
+		System.out.println("Setting up data from txt file....");
+	}
+
+
+}

Design_Patterns_00/Template/DatabaseConnection/.DS_Store

@@ -0,0 +1,19 @@
+package com.javacodegeeks.patterns.templatepattern;
+
+
+/*
+* The connection template pattern 
+*/
+public class TestTemplatePattern {
+
+	public static void main(String[] args) {
+
+		System.out.println("For MYSQL....");
+		ConnectionTemplate template = new MySqLCSVCon();
+		template.run();
+		
+		System.out.println("\nFor Oracle...");
+		template = new OracleTxtCon();
+		template.run();
+	}
+}

Design_Patterns_00/Template/DatabaseConnection/ConnectionTemplate.java

@@ -0,0 +1,127 @@
+
+
+INTENT 
+——————
+Define the skeleton of an algorithm in an operation, deferring some steps to client subclasses. Template Method lets subclasses redefine certain steps of an algorithm without changing the algorithm's structure. Base class declares algorithm 'placeholders', and derived classes implement the placeholders.
+
+
+PROBLEM 
+———————
+Two different components have significant similarities, but demonstrate no reuse of common interface or implementation. If a change common to both components becomes necessary, duplicate effort must be expended.
+
+
+DISCUSSION 
+——————————
+The component designer decides which steps of an algorithm are invariant (or standard), and which are variant (or customizable). The invariant steps are implemented in an abstract base class, while the variant steps are either given a default implementation, or no implementation at all. The variant steps represent "hooks", or "placeholders", that can, or must, be supplied by the component's client in a concrete derived class.
+
+The component designer mandates the required steps of an algorithm, and the ordering of the steps, but allows the component client to extend or replace some number of these steps.
+
+Template Method is used prominently in frameworks. Each framework implements the invariant pieces of a domain's architecture, and defines "placeholders" for all necessary or interesting client customization options. In so doing, the framework becomes the "center of the universe", and the client customizations are simply "the third rock from the sun". This inverted control structure has been affectionately labelled "the Hollywood principle" - "don't call us, we'll call you".
+
+
+
+CHECK LIST 
+——————————
+
+	Examine the algorithm, and decide which steps are standard and which steps are peculiar to each of the current classes.
+
+	Define a new abstract base class to host the "don't call us, we'll call you" framework.
+
+	Move the shell of the algorithm (now called the "template method") and the definition of all standard steps to the new base class.
+
+	Define a placeholder or "hook" method in the base class for each step that requires many different implementations. This method can host a default implementation – or – it can be defined as abstract (Java) or pure virtual (C++).
+
+	Invoke the hook method(s) from the template method.
+
+	Each of the existing classes declares an "is-a" relationship to the new abstract base class.
+
+	Remove from the existing classes all the implementation details that have been moved to the base class.
+
+	The only details that will remain in the existing classes will be the implementation details peculiar to each derived class.
+
+
+RULES OF THUMB 
+——————————————
+
+	Strategy is like Template Method except in its granularity.
+
+	Template Method uses inheritance to vary part of an algorithm. Strategy uses delegation to vary the entire algorithm.
+
+	Strategy modifies the logic of individual objects. Template Method modifies the logic of an entire class.
+
+	Factory Method is a specialization of Template Method.
+
+
+
+
+
+
+
+
+INTRODUCTION 
+————————————
+
+The Template Design Pattern is a behavior pattern and, as the name suggests, it provides a template or a structure of an algorithm which is used by users. A user provides its own implementation without changing the algorithm’s structure.
+
+It is easier to understand this pattern with the help of a problem. We will understand the scenario in this section and will implement the solution using the Template pattern in a later section.
+
+Have you ever connected to a relation database using your Java application? Let’s recall some important steps which are required to connect and insert data into the database. First, we need a driver according to the database we want to connect with. Then, we pass some credentials to the database, then, we prepare a statement, set data into the insert statement and insert it using the insert command. Later, we close all the connections, and optionally destroy all the connection objects.
+
+You need to write all these steps regardless of any vendor’s relational database. Consider a problem where you need to insert some data into the different databases. You need to fetch some data from a CSV file and have to insert it into a MySQL database. Some data comes from a text file and which should be insert into an Oracle database. The only difference is the driver and the data, the rest of the steps should be the same, as JDBC provides a common set of interfaces to communicate to any vendor’s specific relation database.
+
+We can create a template, which will perform some steps for the client, and we will leave some steps to let the client to implement them in its own specific way. Optionally, a client can override the default behavior of some already defined steps.
+
+
+
+
+
+
+
+DESCRIPTION 
+———————————
+
+The Template Pattern defines the skeleton of an algorithm in an operation, deferring some steps to subclasses. Template Method lets subclasses to redefine certain steps of an algorithm without changing the algorithm’s structure.
+
+The Template Method pattern can be used in situations when there is an algorithm, some steps of which could be implemented in multiple different ways. In such scenarios, the Template Method pattern suggests keeping the outline of the algorithm in a separate method referred to as a template method inside a class, which may be referred to as a template class, leaving out the specific implementations of the variant portions (steps that can be implemented in multiple different ways) of the algorithm to different subclasses of this class.
+
+The Template class does not necessarily have to leave the implementation to subclasses in its entirety. Instead, as part of providing the outline of the algorithm, the Template class can also provide some amount of implementation that can be considered as invariant across different implementations. It can even provide default implementation for the variant parts, if appropriate. Only specific details will be implemented inside different subclasses. This type of implementation eliminates the need for duplicate code, which means a minimum amount of code to be written.
+
+
+————————————————————————————————————————————————————————————————————————————————————
+STRUCTURE 
+—————————
+
+AbstractClass
+—————————————
+Defines abstract primitive operations that concrete subclasses define to implement steps of an algorithm.
+
+Implements a template method defining the skeleton of an algorithm. The template method calls primitive operations as well as operations defined in AbstractClass or those of other objects.
+
+ConcreteClass
+—————————————
+Implements the primitive operations to carry.
+————————————————————————————————————————————————————————————————————————————————————
+
+
+
+
+
+
+USAGES 
+——————
+	To implement the invariant parts of an algorithm once and leave it up to subclasses to implement the behavior that can vary.
+
+	When common behavior among subclasses should be factored and localized in a common class to avoid code duplication. You first identify the differences in the existing code and then separate the differences into new operations. Finally, you replace the differing code with a template method that calls one of these new operations.
+
+	To control subclasses extensions. You can define a template method that calls “hook” operations (see Consequences) at specific points, thereby permitting extensions only at those points.
+
+
+TEMPLATE DESIGN PATTERN IN JDK 
+——————————————————————————————
+i.   java.util.Collections#sort()
+ii.  java.io.InputStream#skip()
+iii. java.io.InputStream#read()
+iv.  java.util.AbstractList#indexOf()
+
+
+

Design_Patterns_00/Template/DatabaseConnection/MySqLCSVCon.java

@@ -1,9 +1,12 @@
 package design.design_patterns.templateMethod.barista;
 
+
 public class Coffee extends CaffeineBeverage {
+
 	public void brew() {
 		System.out.println("Dripping Coffee through filter");
 	}
+
 	public void addCondiments() {
 		System.out.println("Adding Sugar and Milk");
 	}

Design_Patterns_00/Template/DatabaseConnection/OracleTxtCon.java

@@ -1,6 +1,7 @@
 package design.design_patterns.templateMethod.barista;
 
 public class Tea extends CaffeineBeverage {
+
 	public void brew() {
 		System.out.println("Steeping the tea");
 	}

Design_Patterns_00/Template/DatabaseConnection/TestTemplatePattern.java

@@ -3,10 +3,13 @@
 public class Barista {
 
 	public static void main(String[] args) {
+
 		Tea tea = new Tea();
 		Coffee coffee = new Coffee();
 		System.out.println("Making tea...");
+
 		tea.prepareRecipe();
+
 		System.out.println("Making coffee...");
 		coffee.prepareRecipe();
 	}

Design_Patterns_00/Template/README.txt

@@ -1,6 +1,7 @@
 package design.design_patterns.templateMethod.sort;
 
 public class Duck implements Comparable<Duck> {
+
 	String name;
 	int weight;
 

Design_Patterns_00/Template/Template_1.png

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

Design_Patterns_00/Template/Template_2.png

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>VisitorPattern</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

Design_Patterns_00/Template/Template_3.png

@@ -0,0 +1,11 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.7
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.7

Design_Patterns_00/Template/barista/Coffee.java

@@ -0,0 +1,16 @@
+package com.javacodegeeks.patterns.visitorpattern;
+
+public class CssClassVisitor implements Visitor{
+
+	@Override
+	public void visit(HtmlElement element) {
+		element.setStartTag(element.getStartTag().replace(">", " class='visitor'>"));
+		
+	}
+
+	@Override
+	public void visit(HtmlParentElement parentElement) {
+		parentElement.setStartTag(parentElement.getStartTag().replace(">", " class='visitor'>"));
+	}
+
+}

Design_Patterns_00/Template/barista/Tea.java

@@ -0,0 +1,6 @@
+package com.javacodegeeks.patterns.visitorpattern;
+
+public interface Element {
+	
+	public void accept(Visitor visitor);
+}