EJB: Singleton ConcurrencyManagement

Tylko jeden watek równocześnie może mieć dostęp do instancji beana oznaczonego @Singleton.
Anotacja @ConcurrencyManagement(ConcurrencyManagementType.BEAN) deaktywuje to ograniczenie i singleton staje sie dostępny dla wielu wątków.

źródło: http://www.e-zest.net/blog/caching-with-periodic-updates-using-ejb-3-1-singleton-and-timer/
źródło: http://www.adam-bien.com/roller/abien/entry/singleton_the_perfect_cache_facade

Wzorce projektowe: strategy

Strategia jest czynnościowym wzorcem obiektowym. Wzorzec składa się z wielu związanych ze sobą algorytmów ukrytych wewnątrz klasy sterującej zwanej Context.

Bardzo łatwo dodaje się nowe algorytmy, poprzez utworzenie nowej klasy implementującej dany interfejs. Conext może w danej chwili mieć wybraną tylko jedną strategię.

package pl.roboczenotatki.designpatterns.strategy;

public interface Vehicle {
	public void makeSound();
}

package pl.roboczenotatki.designpatterns.strategy;

public class Car implements Vehicle{

	@Override
	public void makeSound() {
		System.out.println("Brum from car");
	}
}

package pl.roboczenotatki.designpatterns.strategy;

public class Bus implements Vehicle{

	@Override
	public void makeSound() {
		System.out.println("Brum from bus");
	}
}

package pl.roboczenotatki.designpatterns.strategy;

import java.util.Calendar;

public class App {
	public static void main(String[] args) {
		System.out.println("Design pattern: Strategy");

		Vehicle vehicle = null;
		switch (Calendar.DAY_OF_WEEK) {
		case Calendar.SATURDAY:
		case Calendar.SUNDAY:
			vehicle = new Car();
			break;
		default:
			vehicle = new Bus();
			break;
		}

		vehicle.makeSound();

	}
}

Diagram:
strategy

Wzorce projektowe: Simple Factory

Simple factory jest jednym z wzorców konstrukcyjnych, których zadaniem jest tworzenie obiektów. Wzorzec ten charakteryzuje się tym, że caly proces decyzyjny i konstrukcyjny jest w jednej metodzie.

package pl.roboczenotatki.designpatterns.simpleFactory;

public enum Animal {
	RABBIT, WOLF, BOAR;
}

package pl.roboczenotatki.designpatterns.simpleFactory;

public interface WildAnimal {
	public void showName();
}

package pl.roboczenotatki.designpatterns.simpleFactory;

public class Rabbit implements WildAnimal {

	@Override
	public void showName() {
		System.out.println("I'm rabbit");
	}
}

package pl.roboczenotatki.designpatterns.simpleFactory;

public class Wolf implements WildAnimal {
	@Override
	public void showName() {
		System.out.println("I'm wolf");
	}
}

package pl.roboczenotatki.designpatterns.simpleFactory;

public class Boar implements WildAnimal{

	@Override
	public void showName() {
		System.out.println("I'm boar");
	}
}

package pl.roboczenotatki.designpatterns.simpleFactory;

/** Zastosowano tutaj rowniez wzorzec Singleton */
public class AnimalFactory {
	private static AnimalFactory INSTANCE;

	private AnimalFactory(){}

	public static AnimalFactory getInstance(){
		if(INSTANCE == null){
			INSTANCE = new AnimalFactory();
		}
		return INSTANCE;
	}

	public WildAnimal createWildAnimal(Animal animal){
		switch (animal) {
		case RABBIT:
			return new Rabbit();
		case WOLF:
			return new Wolf();
		default:
			return new Boar();
		}
	}
}

package pl.roboczenotatki.designpatterns.simpleFactory;

public class App
{
    public static void main( String[] args )
    {
    	System.out.println( "Design pattern: Simple factory" );

    	WildAnimal wildAnimal = AnimalFactory.getInstance().createWildAnimal(Animal.RABBIT);
    	wildAnimal.showName();
    }
}

Wzorce projektowe: Template method

Wzorzec projektowy Template method jest wzorcem operacyjnym. Definiuje on za pomocą abstrakcji szkielet algorytmu, który w klasach potomnych jest w pełni realizowany. Na początku tworzona jest klasa zawierająca ogólne kroki algorytmu zapisane jako metody abstrakcyjne. Klasy potomne nadpisują te abstrakcyjne metody implementując rzeczywiste akcje.

Dzięki takiemu podejściu szkielet algorytmu trzymany jest w jednym miejscu, a jego mniejsze kroki mogą być zmieniane w podklasach.

Template Method jest wykorzystywany we wzorcach Strategia i Abstract Factory.

package pl.roboczenotatki.designpatterns.templateMethod;

public class App 
{
    public static void main( String[] args )
    {
        System.out.println( "Design pattern: Template method" );
        
        AbstractAlgorithm algorithm = new PrintAlgorithm();        
        algorithm.run();
    }
}

AbstractAlgorithm

package pl.roboczenotatki.designpatterns.templateMethod;

public abstract class AbstractAlgorithm {

	public void run(){
		before();
		doRun();
		after();
	}
	
	private void before(){
		System.out.println("Before");
	}
	
	private void after() {
		System.out.println("After");
	}
	
	protected abstract void doRun();
}

PrintAlgorithm

package pl.roboczenotatki.designpatterns.templateMethod;

public class PrintAlgorithm extends AbstractAlgorithm{

	@Override
	protected void doRun() {
		System.out.println("PrintAlgorithm is running");
	}

}

Wzorce projektowe: mediator

Mediator znajduje zastosowanie w sytuacji, gdy wiele obiektów o wspólnym interfejsie musi komunikować się ze sobą w celu wykonania określonego zadania. Najprostszym, lecz trochę naiwnym rozwiązaniem jest powiązanie wszystkich obiektów ze sobą w topologii grafu pełnego. Takie rozwiązanie jest jednak słabo skalowalne: dołączenie kolejnego obiektu powoduje konieczność powiadomienia o zmianie wszystkich pozostałych, aby potrafili skomunikować się z nowym uczestnikiem interakcji. Ponadto powoduje, że mechanizm komunikacji jest rozproszony, co utrudnia jego modyfikację i dalszy rozwój.

Wzorzec Mediator proponuje topologię gwiazdy, w której centrum znajduje się właśnie obiekt Mediator. Posiada on referencje do pozostałych obiektów (Colleague) i zna ich zakres odpowiedzialności. Komunikacja pomiędzy obiektami Colleague wymaga pośrednictwa Mediatora, który potrafi przekazać komunikat do właściwego odbiorcy.

Mediator

package pl.roboczenotatki.designpatterns.mediator;

public interface Mediator {

	public void notifyAll(String message,Colleague authorColleague);
}

Colleague

package pl.roboczenotatki.designpatterns.mediator;

public interface Colleague {

	public void send(String message);

	public void receive(String message);

	public String getName();

}

ConcreteColleague

package pl.roboczenotatki.designpatterns.mediator;

public class ConcreteColleague implements Colleague{
	private Mediator mediator;
	private String name;

	public ConcreteColleague(Mediator mediator, String name) {
		super();
		this.mediator = mediator;
		this.name = name;
	}

	@Override
	public void receive(String message) {
		System.out.println("[Colleague] '"+getName()+"' received message: " + message);
	}

	public Mediator getMediator() {
		return this.mediator;
	}

	@Override
	public void send(String message) {
		getMediator().notifyAll(message, this);
	}

	public String getName() {
		return this.name;
	}
}

ConcreteMediator

package pl.roboczenotatki.designpatterns.mediator;

import java.util.ArrayList;
import java.util.List;

public class ConcreteMediator implements Mediator {

	private List colleagues;

	public List getColleagues() {
		if(colleagues == null){
			colleagues = new ArrayList();
		}
		return colleagues;
	}

	public void addColleague(Colleague colleague){
		getColleagues().add(colleague);
	}

	public void addColleagues(List colleagues){
		getColleagues().addAll(colleagues);
	}

	@Override
	public void notifyAll(String m, Colleague authorColleague) {
		System.out.println("[Mediator] Message from author '" + authorColleague.getName() + "' : " + m);
		for (Colleague c : getColleagues()) {
			c.receive(m);
		}
	}
}

 

package pl.roboczenotatki.designpatterns.mediator;

import java.util.Arrays;

public class App
{
    public static void main( String[] args )
    {
    	System.out.println( "Design pattern: mediator" );

    	ConcreteMediator mediator = new ConcreteMediator();

    	Colleague col1 = new ConcreteColleague(mediator, "1");
    	Colleague col2 = new ConcreteColleague(mediator, "2");
    	Colleague col3 = new ConcreteColleague(mediator, "3");
    	Colleague col4 = new ConcreteColleague(mediator, "4");

    	//dodajemy obslugiwanych kolegow
    	mediator.addColleagues(Arrays.asList(col1,col2,col3,col4));

    	//col1 powiadamia pozostalych - rozsyla poprzez mediatora
    	col1.send("hello from 1");
    }
}

Wynik wykonania:

Design pattern: mediator
[Mediator] Message from author '1' : hello from 1
[Colleague] '1' received message: hello from 1
[Colleague] '2' received message: hello from 1
[Colleague] '3' received message: hello from 1
[Colleague] '4' received message: hello from 1

Diagram wzorca mediator:
mediator