Design patterns (Observer, Singleton, Factory Method and Adapter) implemented in Dojo Toolkit JS

This is a list of design patterns, implemented in Dojo JS

I'v found difficult to work with some restrictions as the use of static variables, in this kind of implementation

Observer

  //Observer pattern

      dojo.declare("com.dev.dojo.Observer",[],
    	{
    	  state: "observer",
    	  obs: null,
    	 constructor:function(obl){
    		  this.obs = obl;
    	  },
    	  update: function(sta){
    		 this.state = sta;
    		 status = this.obs.updateObserver(this);
    	  
    	  	console.log("udate observer result for "+ this + ": " +  status);
    	  }
    	  
    		  
    	});
      
      dojo.declare("com.dev.dojo.Observable",[],
    	    	{
    	    	  state: "observable",
    	    	  observers: [],
    	    	 
    	    	 Observervable:function(obss){
    	    		  this.observers = obss;
    	    	  },
    	    	  addObserver: function(o){
    	    		  idx = dojo.indexOf(this.observers,o);
    	    		  if(idx!=null && idx>=0)
    	    			  this.observers[idx] = o;
    	    		  else
    	    			this.observers.push(o);  
    	    	  },
    	    	  getObservers: function(){
    	    		  return this.observers;
    	    	  },
    	    	  notifyAll: function(stat){
    	    		  this.state = stat;
    	    		  for(i=0;i< this.observers.length;i++)
                	     this.observers[i].update(this.state);
    	    	  },
    	    	  updateObserver:function(observer){
    	    		  idx = dojo.indexOf(this.observers,observer);
    	    		  if(idx!=null && idx>=0){
    	    			  this.observers[idx] = observer;
    	    		  	 return 1;
    	    		  }
    	    	  	return -1;
    	    	  }
    	    	  ,
    	    	  displayObservers: function(s) {
    	    		  for(i=0;i
Singleton
//Singleton pattern
var created = false;
dojo.declare("com.dev.dojo.Singleton",[],{
	
	singleton:null,
	__isCreated__: created,
	
	getInstance: function(){
		if(!this.__isCreated__){
			created = true;
			this.singleton = new com.dev.dojo.Singleton();
		}
		return this.singleton;
	},
	
	doTask: function(seconds){
		for(i=0;i
    
Factory Method 
    
 //Factory method pattern
    
    dojo.declare("com.dev.dojo.Animal",[],{
    	type:"Animal",
    	saySomething: function(){
    		return "I'm too generic to say something";
    	}
    });
    dojo.declare("com.dev.dojo.Dog",[com.dev.dojo.Animal],{
    	type:"Dog",
    	saySomething: function(){
    		return "Guau,guau,guau";
    	}
    });
   
    dojo.declare("com.dev.dojo.Tiger",[com.dev.dojo.Animal],{
    	type:"Tiger",
    	saySomething: function(){
    		return "Roarrrr,roarrrrrr";
    	}
    });
   
    dojo.declare("com.dev.dojo.Factory",[],{
    
    	getInstance:function(type){
    		var instance = null;
    		if(type==new com.dev.dojo.Animal().type)
    			instance = new com.dev.dojo.Animal();
    		else if(type==new com.dev.dojo.Tiger().type)
    			instance = new com.dev.dojo.Tiger();
    		else if(type==new com.dev.dojo.Dog().type)
    			instance = new com.dev.dojo.Dog();
    		
    		return instance;
    	}
    	
    });
    var t = "Dog";
    var o = com.dev.dojo.Factory().getInstance(t);
    
    alert(o.saySomething());
    
    t="Tiger";
    
    o = com.dev.dojo.Factory().getInstance(t);
    
    alert(o.saySomething());
    
    //End of factory method
    
    
    
Adapter 
    
    
    //Adapter pattern
     /* Example of adapter pattern*/
      
      function FlyingEngine() {
    	  var operation = "Principal ";
    	  var state = -1;
    	  this.turnOnEngine=function(){
    		  this.operation += "Engine is turning ON\n";
    	  	  this.state = 0;
    	  }
    	  this.takingOver=function(){
    		  if(this.state<1)
    			  this.operation += "Can't take over until engine is turn on";
    		  this.operation += "Taking over\n";
    		  this.state=2;
    	  }
    	  
    	  this.flying=function(){
    		  if(state<2)
    			  operation+="Not posible to fly until taking over";
    		  this.operation += "FLYING\n";
    		  this.state=3;
    	  }
    	  
    	  
      }
      
      function Helicopter(){
    	  var operation = "Principal ";
    	  var flyingEngine = new FlyingEngine();
    	  this.rotorsWarm=function(){
    		  if(this.state==0){
    		 /*adapter->*/ flyingEngine.operation = "Rotors ";
    		 				flyingEngine.turnOnEngine();
    		 				this.operation += flyingEngine.operation;
    			  this.operation += "warming rotors:"
    			  for(i=0;i<5;i++)
    	  		this.operation +=i
    		 }
    		  this.operation += "\n";
      		
      		this.state+=1;
    	  	}
      
      
      }
      
      
      dojo.extend(Helicopter,new FlyingEngine());
      
      var h1 = new Helicopter();
      var s = "";
      h1.turnOnEngine();
      h1.rotorsWarm();
      h1.takingOver();
      h1.flying();
      
      s = h1.operation;
      
      alert(s);
      
      

Design Patterns code examples

Index

Gof Patterns code examples

You can download code from GitHub Updated

You can find implementation in Java of the following design patterns:

Design Patterns
Decorator	Car decorator example
Observer	Subject, suscribers example
Singleton	Concurrent access example
Abstract Factory	Abstract factory that creates virtual robots example
Command	Invoker, command, receiver (simulates a cars race)
Adapter	International facilities adapter
Facade	Mobile Clinic facade example
MVC	Compound pattern: Model as Observer, Controller as Strategy, View as Composite (ref:HFDesign Patterns)

GitHub:

https://github.com/Leonarden/gofPatternsExamples

Proxy pattern example

Index

Proxy pattern

Includes code that you can download from GitHub

Other proxy pattern examples

Theory

The proxy pattern Provide a surrogate or placeholder for another object to control access to it.

One reason for controlling access to an object is to defer the full cost of its creation and initialization until we actually need to use it.

In this example we have simulated a remote communication as you will see.

The UML model is

Figure-1

Code of the application

Comm Interface

package com.patterns.proxy;

public interface Comm {
	public String receive();
	public boolean reset();


}

CommImpl Class

package com.patterns.proxy;

public class CommImpl implements Comm {
private static int INFOLENGTH = 10;
private boolean isAlive = false;
private String information;
public String receive() {
	// TODO Auto-generated method stub
	if(isAlive) mockCall();
	return read();
}
public boolean reset() {
	if(isAlive) isAlive=false;
	else isAlive = true;
	return isAlive;
}
public String read() {
	// TODO Auto-generated method stub
	if(isAlive)
	information = this.generateInfo();
	return information;
}
 void mockCall() {
	try {
		Thread.sleep(500);
	} catch (InterruptedException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
}

String generateInfo() {
	StringBuffer sb = new StringBuffer();
	String base = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
	for(int i=0;i


CommProxy Class

package com.patterns.proxy;

public class CommProxy implements Comm{

	private static CommImpl comm;
    private boolean isAlive;
    
	public CommProxy() {
		comm = new CommImpl();
	}
	
	public String receive() {
	   
		if(isAlive) /*new information arrived */
			return comm.receive(); 
		else
			return "NO NEW INFORMATION=" + comm.receive();
	}

	public boolean reset() {
		isAlive = comm.reset();
		return isAlive;
		// TODO Auto-generated method stub
		
	}


	
}




App Class

ckage com.patterns.proxy;

/**
 
 *
 */
public class App 
{
    public static void main( String[] args )
    {
    	String message;
        CommProxy proxy = new CommProxy();
        
        proxy.reset();
        message = proxy.receive();
        System.out.println("Mess-1"+ message);
        proxy.reset();
        message = proxy.receive();
        System.out.println("Mess-2"+ message);
        proxy.reset();
        message = proxy.receive();
        System.out.println("Mess-3"+ message);
    }
}

GitHub:

https://github.com/Leonarden/javaProxyPatternSample

Java 9 Concurrency new CompletonStage and CompletableFuture

Index

Java 9 concurrency

CompletableFuture Example

More Examples!

Introduction

Many Java applications require of concurrent operations. When using concurrency there are common risk that have to be avoided such as memory leaking, race condition, callback hell, disjointed error handling… In version 8, Java provides a new class CompletableFuture. This class has about 50 methods mainly for: compose, combine and execute asychronous steps and also to handle errors.

Concurrency classes provided by Java as  Future and ExecutorService interfaces since version 5 to handle the asynchronous operations.

The Future interface is a placeholder for a result from an asynchronous operation which can be a Runnable or Callable instance. The ExecutorService interface submits an asynchronous operation and returns a Future object. The caller can use its get method to wait for the operation or cancel method to try to cancel the operation. 

Future has the following methods: isDone() : Checks if the computation is completed. isCancelled() : checks if the task was cancelled before it is completed normally. get() : blocks for its completion and to retrieve the result of the computation. get​(long timeout, TimeUnit unit) : blocks if necessary for at most the given time for this future to complete, and then returns its result, if available. cancel() : cancels execution of this task if possible.

Java 8 Introduced a new Class for dealing with concurrency problems caused by Future like blockings, also implementing interfaces Runnable and CompletionStage.

Java 8 Concurrency new CompletonStage and CompletableFuture

Java 8 provided a new interface : – java.util.concurrent.CompletionStage  This interface defines a “stage” of possible asynchronous computation. All its methods return an instance of “CompletionStage” itself. This way multiple Completionstages can be chained together to complete a group of tasks.

Java 8 also introduced a new class: a new 

java.util.concurrent.CompletableFuture*

This class implements both: 1) Future  and 2) CompletionStage interfaces. This class provides static methods as starting points of concurrent operations as we will see below.

Here are some of the more common used methods:

1) - supplyAsync(Supplier supplier)  : Create a CompletableFuturence out of Suplier functional type.

2) runAsync(Runnable action) : Create a CompletableFuture instance out of Runnable functional type.

3) completeExceptionally(Throwable ex) : Return true if this invocation caused this CompletableFuture to transition to a completed state, else false.

4) thenRun(Runnable action)  : Execute the action when it completes normally.

5) thenApply(Function f) : Return a new CompletionStage.

6) thenAccept(Consumer action) : Return a new CompletionStage.

7) thenCombine(Future fu, Function foo) : Combines a  Future  and a  Function  with two arguments to process both results.

8) thenCompose(Function f) : To chain two Futures sequentially.

.

Its important to understand how the new threads are obtained. In fact by default those threads are obtained from "ForkJoinPool.commonPool()", but we have also the possibility to create our Executor (see: "Executors" API) and pass it to the CompletableFuture callbacks.

//Creating a new executor

Executor executor = Executors.newFixedThreadPool(5);

//then passing to CompletableFuture.supplyAsync(supplier, executor);

We can also launch new sync or async callback by calling "thenApply" operation. This callback offer to variants sync (same thread) or async(a new thread) -

 CompletableFuture thenApply(Function func)
 CompletableFuture thenApplyAsync(Function func)
 CompletableFuture thenApplyAsync(Function fn, Executor executor)

Code Example:

ExampleConcurrency.java

package pub.Java.src;

import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class ExampleConcurrency {

	public static void main(String[] args) {
		
		
		/* Example of CompletableFuture */
		
		
		/*First completable Future*/
		
		CompletableFuture firstCompletableFuture = new CompletableFuture();
		String s = "Is there someone?  ";
		String r = null;
		try {
			
			 firstCompletableFuture.complete(": Yes! Hello Concurrent");;
			r =  firstCompletableFuture.get();
			s = s + r;
			 
		} catch (InterruptedException | ExecutionException e) {
	
			e.printStackTrace();
		}
		
		System.out.println("Result: " + s);
		
		
		/* "runAsync" : Example accepts a Runnable this time implemented with Anonymous Class */
		
		CompletableFuture cfuture = new CompletableFuture().runAsync(new Runnable() {
			
			@Override
			public void run() {
				String[] mesg = {"We","wait","in a" ,"different", "Thread"};
				int i;
				try {
					
					for(i = 0;i cfuture1 = new CompletableFuture().runAsync( () ->
  {		
	  String[] mesg = {"We","wait","in a" ,"different", "Thread"};
  
		int i;
		try {
			
			for(i = 0;i myLuckyNumberFuture = new CompletableFuture().supplyAsync(()->{
/* NOTE: STREAMS HAVE TO BE USED CAREFULLY IN CONCURRENT OPERATIONS
** In this case We need to use a Stream Supplier to get a new open Stream to invoke a new operation 
 * ONCE we have invoked a Terminal Operation (in this case ) that closes the Stream
 * That is the way to AVOID the:" java.lang.IllegalStateException: stream has already been operated upon or closed"
 * */
	Supplier> supplierOfStreamNums = ()->Stream.of(0,1,2,3,4,5,6,7,8,9).parallel();
	
	List luckList = supplierOfStreamNums.get().collect(Collectors.toList());	
	int ridx = (int) (Math.random()*10) % 10;
			
	return (Integer) luckList.get(ridx);

});	
/* We add the callback "thenApply"  Function to modify the result obtained before */
myLuckyNumberFuture.thenApply((   
		l ->{
Integer n = l;
	if(n%2==0)
		n = n +1;
	else
		n = n -1;
	return n;
}));
/* add callback "thenAccept" Consumer to consume the Integer generated, in this case by printing it */ 
myLuckyNumberFuture.thenAccept(n->System.out.println("My lucky number is (I'm in a different thread) : " + n));

//Invoking the blocking the CompletableFuture blocking operation "get"  */
Integer myLuckyNumber = -1;
try {
	 myLuckyNumber = myLuckyNumberFuture.get();

	System.out.println("My lucky number is : " + myLuckyNumber);

} catch (InterruptedException | ExecutionException e) {
	e.printStackTrace();
}



}

	

}