easy blog

Facade Pattern

-system의 복잡함을 감추고 client에 interface를 제공.

ShapeMaker.java ( facade class )

public class ShapeMaker {
    Circle circle;
    Rectangle rectangle;
    Square square;

    public ShapeMaker(){
        circle = new Circle();
        rectangle =new Rectangle();
        square = new Square();
    }

    public void drawCircle(){
        circle.draw();
    }
    public void drawRectangle(){
        rectangle.draw();
    }
    public void drawSqaure(){
        square.draw();
   }
}

결과 :

07-20 13:48:21.208 11008 11008 D Shape   : Circle draw

07-20 13:48:21.208 11008 11008 D Shape   : Rectangle draw

07-20 13:48:21.208 11008 11008 D Shape   : Square draw

출처 :

https://www.tutorialspoint.com/design_pattern/facade_pattern.htm

Decorator pattern 

-이미 존재하는 객체에 대해 새로운 기능을 추가하는 것을 위한 pattern

-structural pattern으로 existing class의 wrapper로써 작동한다.

-decorator class를 작성하며, original class를 wrap하여 새 기능을 추가하고 원래의 structure는 그대로 유지시킨다.

Main 호출 부분

ShapeDecorator를 확장한 RedShapeDecorator를 사용하여 기존의 Circle객체의 기능을 추가하는 것이 가능해졌다.

	Circle circle = new Circle();
	//existing object
	circle.draw();
	//decorating circle
	RedShapeDecorator redShapeDecorator1 = new RedShapeDecorator(circle);
	redShapeDecorator1.draw();
	RedShapeDecorator redShapeDecorator2 = new RedShapeDecorator(new Rectangle());
	redShapeDecorator2.draw();

ShapeDecorator class가 abstract class 임에 주목
ShapeDecorator.java

public abstract class ShapeDecorator implements Shape {
    protected Shape decoratorShape;

    public ShapeDecorator(Shape decoratedShape){
        this.decoratorShape=decoratedShape;
    }

    @Override
    public void draw() {
        decoratorShape.draw();
    }
}

RedShapeDecorator.java

public class RedShapeDecorator extends ShapeDecorator {
    public RedShapeDecorator(Shape decoratedShape) {
        super(decoratedShape);
    }

    @Override
    public void draw() {
        decoratorShape.draw();
        setRedBoard(decoratorShape);

    }

    private void setRedBoard(Shape decoratorShape) {
        Log.d(TAG, "Border Color in Red");
    }
}

public interface Shape {
    public static final String TAG = "shape";
    void draw();
}

public class Rectangle implements Shape {
    @Override
    public void draw() {
        Log.d(TAG, "draw rectangle");
    }
}

public class Circle implements Shape {
    @Override
    public void draw() {
        Log.d(TAG, "draw Circle");
    }
}

결과 : 

07-20 12:00:21.018  8526  8526 D shape   : draw Circle

07-20 12:00:21.018  8526  8526 D shape   : draw Circle

07-20 12:00:21.018  8526  8526 D shape   : Border Color in Red

07-20 12:00:21.018  8526  8526 D shape   : draw rectangle

07-20 12:00:21.018  8526  8526 D shape   : Border Color in Red

출처 : 

https://www.tutorialspoint.com/design_pattern/decorator_pattern.htm

Class 간의 관계를 Diagram을 통해 쉽게 

이해하기 위해 하기의 내용은 숙지하는 것이 좋다.

출처 : 

http://webie.tistory.com/149

Composite pattern 

-group 객체를 single 객체와 유사한 방식으로 사용.

-structural pattern의 하나이며, 자기 자신의 객체를 트리 구조로 만들어 사용함.

-자신의 group 객체를 포함하는 class를 만든다.

(Employee의 subordinates)

Employee.java

public class Employee {
    private String name;
    private String dept;
    private int salary;
    private List subordinates;

    public Employee(String name, String dept, int salary){
        this.name=name;
        this.dept=dept;
        this.salary=salary;
        subordinates= new ArrayList<>();
    }

    public void add(Employee e){
        subordinates.add(e);
    }
    public void remove (Employee e){
        subordinates.remove(e);
    }

    public List getSubordinates(){
        return subordinates;
    }

    public String toString(){
        return ( "Emp : name :"+name+" dept : "+dept +" salary : "+salary );
    }
}

	Employee CEO = new Employee("John","CEO", 30000);

	Employee headSales = new Employee("Robert","Head Sales", 20000);

	Employee headMarketing = new Employee("Michel","Head Marketing", 20000);

	Employee clerk1 = new Employee("Laura","Marketing", 10000);
	Employee clerk2 = new Employee("Bob","Marketing", 10000);

	Employee salesExecutive1 = new Employee("Richard","Sales", 10000);
	Employee salesExecutive2 = new Employee("Rob","Sales", 10000);

	CEO.add(headSales);
	CEO.add(headMarketing);

	headSales.add(clerk1);
	headSales.add(clerk2);

	headMarketing.add(salesExecutive1);
	headMarketing.add(salesExecutive2);

	for ( Employee headEmp : CEO.getSubordinates()){

		Log.d (TAG, headEmp.toString());
		for (Employee e : headEmp.getSubordinates()){
			Log.d (TAG, e.toString() );
		}
	}

Filter pattern or Criteria pattern

- 객체의 set에서 특정 criteria를 이용하여 decoupling 하는 역할을 하는 pattern

- Criteria interface와 해당 interface의 implementation을 사용한다.

- structual pattern의 하나.

- multiple criteria를 조합하여 하나의 single criteria를 만들어 낼 수 있다. -> combination criteria.

Person.java

public class Person {
	
   private String name;
   private String gender;
   private String maritalStatus;

   public Person(String name, String gender, String maritalStatus){
      this.name = name;
      this.gender = gender;
      this.maritalStatus = maritalStatus;		
   }

   public String getName() {
      return name;
   }
   public String getGender() {
      return gender;
   }
   public String getMaritalStatus() {
      return maritalStatus;
   }	
}

public interface Criteria {
    public List meetCriteria(List persons);
}

public class CriteriaMale implements Criteria {
    @Override
    public List meetCriteria(List persons) {
        List malePersons = new ArrayList();

        for (Person p : persons ){
            if (p.getGender().equalsIgnoreCase("male"))
                malePersons.add(p);
        }

        return malePersons;
    }
}

public class CriteriaFemale implements Criteria {
    @Override
    public List meetCriteria(List persons) {
        List femalePersons = new ArrayList();

        for (Person p : persons ){
            if (p.getGender().equalsIgnoreCase("Female"))
                femalePersons.add(p);
        }

        return femalePersons;
    }
}

public class CriteriaSingle implements Criteria {
    @Override
    public List meetCriteria(List persons) {
        List singlePersons = new ArrayList<>();

        for (Person p : persons){
            if(p.getMartialStatus().equalsIgnoreCase("single"))
                singlePersons.add(p);
        }

        return singlePersons;
    }
}

public class AndCriteria implements Criteria {

    private Criteria criteria;
    private Criteria otherCriteria;

    public AndCriteria(Criteria criteria, Criteria otherCriteria){
        this.criteria=criteria;
        this.otherCriteria=otherCriteria;
    }

    @Override
    public List meetCriteria(List persons) {

        List firstCriteriaPersons = criteria.meetCriteria(persons);
        return otherCriteria.meetCriteria(firstCriteriaPersons);
    }
}

public class OrCriteria implements Criteria {
    private Criteria criteria;
    private Criteria otherCriteria;

    public OrCriteria(Criteria criteria, Criteria otherCriteria){
        this.criteria=criteria;
        this.otherCriteria=otherCriteria;
    }

    @Override
    public List meetCriteria(List persons) {

        List firstCriteriaPersons = criteria.meetCriteria(persons);
        List otherCriteriaPersons = otherCriteria.meetCriteria(persons);
        for (Person p : otherCriteriaPersons){
            if( !firstCriteriaPersons.contains(p))
                firstCriteriaPersons.add(p);
        }
        return firstCriteriaPersons;
    }
}

	List persons = new ArrayList<>();
	persons.add(new Person("Robert","Male", "Single"));
	persons.add(new Person("John", "Male", "Married"));
	persons.add(new Person("Laura", "Female", "Married"));
	persons.add(new Person("Diana", "Female", "Single"));
	persons.add(new Person("Mike", "Male", "Single"));
	persons.add(new Person("Bobby", "Male", "Single"));

	Criteria male = new CriteriaMale();
	Criteria female = new CriteriaFemale();
	Criteria single = new CriteriaSingle();
	Criteria singleOrFemale = new OrCriteria(female,single);
	Criteria maleSigle = new AndCriteria(male,single);

	Log.d(TAG, "male list");
	printPeople(male.meetCriteria(persons));
	Log.d(TAG, "female list");
	printPeople(female.meetCriteria(persons));
	Log.d(TAG, "single list");
	printPeople(single.meetCriteria(persons));
	Log.d(TAG, "single or female list");
	printPeople(singleOrFemale.meetCriteria(persons));
	Log.d(TAG, "single and male list");
	printPeople(maleSigle.meetCriteria(persons));

Bridge pattern

-implementaion으로부터 abstraction을 decouple할 때 사용.

-structural pattern으로 bridge structure를 implement 및 abstract class에 제공.

-두 타입의 class들은 구조적으로 서로에게 영향을 주지 않고 변경될 수 있다.(변경에 대하여 열린 구조로 변경됨)

DrawAPI : bridge implementer interface.

RedCircle, GreenCircle : concrete bridge implementer classes

Shape : abstract class 

Circle : concrete class implementing the Shape interface.

에제 설명 :

Shape 과 DrawAPI가 brige structure를 가지며,

Shape는 abstraction hierarchy, DrawAPI를 implementation hierarchy로 분리됨.

Shape은 DrawAPI를 멤버로 가져가 concrete class인 Circle 구현에 사용한다.

각 hierarchy는 서로 영향을 받지 않은채 수정이 가능하다.

간단히 표현하자면, Shape은 interface부분(껍데기), DrawAPI는 implementation이 구체화된 부분(실질적 내용)으로 볼 수 있다.

Main 호출 부분에선 어떤 implementation을 사용할지 결정할 수 있다.

그리고 실제 interface를 사용하는 부분에서는 이와는 독립적으로 method를 호출한다.

	Shape shape1 = new Circle(1,2,3, new RedCircle());
	Shape shape2 = new Circle(10,20,30, new GreenCircle());
	shape1.draw();
	shape2.draw();

public abstract class Shape {
    protected DrawAPI mDrawAPI;
    protected Shape( DrawAPI d ){
        mDrawAPI=d;
    }
    public abstract String draw();
}

public interface DrawAPI {
    public final String TAG = "hello";
    public void drawCircle(int radius, int x, int y);
}

public class Circle extends Shape {
    private int x;
    private int y;
    private int radius;

    public Circle(int x, int y, int radius, DrawAPI d){
       super(d);
       this.x=x;
       this.y=y;
       this.radius=radius;
    }

    @Override
    public String draw() {
        mDrawAPI.drawCircle(radius,x,y);
        return "draw";
    }
}

public class RedCircle implements DrawAPI {
    @Override
    public void drawCircle(int radius, int x, int y) {
        Log.d(TAG, "Draw RedCircle : x"+x+" y="+y+" radius="+radius);
    }
}

public class GreenCircle implements DrawAPI {
    @Override
    public void drawCircle(int radius, int x, int y) {
        Log.d(TAG, "Draw GreenCircle : x"+x+" y="+y+" radius="+radius);
    }
}

Adapter pattern

-호환되지 않는 독립적인 interface간의 bridge로써 동작.

-위 interface를 연결하기 위한 class를 포함한다.

user는 기존의 AudioPlayer에서 adapter를 사용하는지에 대해 알지 못하며, 

mp3만 사용하던 기존에 비해서 단지 기능이 추가 된것으로 보임.

Main 호출 부분: 

	AudioPlayer mPlayer = new AudioPlayer();
	mPlayer.play("mp3","hi mp3");
	mPlayer.play("vlc","hi vlc");
	mPlayer.play("mp4","hi mp4");
	mPlayer.play("avi","hi avi");

MediaPlayer, AdvancedMediaPlayer 두개의 인터페이스에는 사실상 공통점이 없다.

public interface MediaPlayer {
    public  void play(String audioType, String fileName);
}

public interface AdvancedMediaPlayer {
    public void playVlc(String fileName);
    public void playMp4(String fileName);
}

class MediaAdapter implements MediaPlayer {

    AdvancedMediaPlayer advancedMediaPlayer;
    public MediaAdapter(String audioType) {
        if (audioType.equalsIgnoreCase("vlc"))
            advancedMediaPlayer = new VlcPlayer();
        else if (audioType.equalsIgnoreCase("mp4"))
            advancedMediaPlayer = new Mp4Player();
    }

    @Override
    public void play(String audioType, String fileName) {
        if(audioType.equalsIgnoreCase("vlc"))
            advancedMediaPlayer.playVlc(fileName);
        else if ( audioType.equalsIgnoreCase("mp4"))
            advancedMediaPlayer.playMp4(fileName);

    }
}

public class AudioPlayer implements MediaPlayer {
    MediaAdapter mediaAdapter;
    @Override
    public void play(String audioType, String fileName) {
        if ( audioType.equalsIgnoreCase("mp3")) {
            Log.d("hello", "Playing mp3 name :" + fileName);
        }
        else if (audioType.equalsIgnoreCase("vlc") || audioType.equalsIgnoreCase("mp4")){
            mediaAdapter = new MediaAdapter(audioType);
            mediaAdapter.play(audioType, fileName);
        }else{
            Log.d("hello", "Invalid audio type"+audioType+" is not supported");
        }
    }
}

public class Mp4Player implements AdvancedMediaPlayer {
    @Override
    public void playVlc(String fileName) {
        return;
    }

    @Override
    public void playMp4(String fileName) {
        Log.d("hello", "Playing mp4 Name :"+fileName);
    }
}

public class VlcPlayer implements AdvancedMediaPlayer {
    @Override
    public void playVlc(String fileName) {
        Log.d("hello", "Playing vlc name :"+fileName);
    }

    @Override
    public void playMp4(String fileName) {
        return;
    }
}

Prototype pattern 

-performance를 염두하고 clone객체를 생성하는 것을 말함.

-역시나 괜찮은 creational pattern 중 하나.

-실제 객체를 생성하는 것이 어려운 경우 prototype interface는 현재 객체에 대한 clone을 만든다.

-일례로, 무거운 db operation이 후 객체가 생성되는 경우, 객체를 cache할 수 있으며 clone을 리턴하므로써, db operation에 대한 호출을 줄인다.

- Clonable interface를 Shape에서 구현한다. (override clone method ). 

문맥 상, prototype 중의 하나로 Clonable로 인식 가능.

Main 호출 부에서 loadCache를 호출하여 overhead가 있는 객체 생성을 미리하여 type지정 후,

HashMap에 저장하여  getShape으로 clone된 객체를 얻오는 것이 가능하다.

	ShapeCache.loadCache();
	Shape clonedShape1 = (Shape) ShapeCache.getShape("1");
	Log.d("hello","shape1 : "+clonedShape1.getType());
	clonedShape1.draw();

	Shape clonedShape2 = (Shape) ShapeCache.getShape("2");
	Log.d("hello","shape2 : "+clonedShape2.getType());
	clonedShape2.draw();

	Shape clonedShape3 = (Shape) ShapeCache.getShape("3");
	Log.d("hello","shape3 : "+clonedShape3.getType());
	clonedShape3.draw();

public abstract class Shape implements Cloneable{
    protected final String TAG = Shape.class.getSimpleName();
    private String id;
    protected String type;
    public abstract void draw();

    public String getType(){
        return type;
    }
    public void setType(String id){
        this.id = id;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    @Override
    protected Object clone()  {
        Object clone = null;
        try {
            clone= super.clone();

        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }

        return clone;
    }
}

public class ShapeCache {

    private static HashMap shapeMap = new HashMap();
    public static Shape getShape(String shapeId){
        Shape cacheShape = shapeMap.get(shapeId);
        return (Shape) cacheShape.clone();
    }

    //assume that each Shape need database update.
    public static void loadCache(){
        Circle circle = new Circle();
        circle.setId("1");
        shapeMap.put(circle.getId(), circle);

        Square square = new Square();
        square.setId("2");
        shapeMap.put(square.getId(), square);

        Rectangle rectangle  = new Rectangle();
        rectangle.setId("3");
        shapeMap.put(rectangle .getId(), rectangle);
    }

}

public class Circle extends Shape {
    //private final String TAG = Circle.class.getSimpleName();

    public Circle(){
        this.type="Circle";
    }
    @Override
    public void draw() {
        Log.d(TAG, "Circle draw");
    }
}
public class Rectangle extends Shape {
    //private final String TAG = Rectangle.class.getSimpleName();

    public Rectangle(){
        this.type="Rectangle";
    }

    @Override
    public void draw() {
        Log.d(TAG, "Rectangle draw");
    }
}
public class Square extends Shape {
    //private final String TAG = Square.class.getSimpleName();

    public Square(){
        this.type="Shape";
    }
    @Override
    public void draw() {
        Log.d(TAG, "Square draw");
    }
}

-Builder pattern 은 간단한 객체를 이용해 단계별 접근법으로 복잡한 객체를 만듭니다.

-Builder class는 단계별로 최종 객체를 만듭니다. 이 Builder는 다른 객체와 독립적입니다.

Main 호출 부분

MealBuilder mb = new MealBuilder();
Meal mVegMeal=mb.prepareVegMeal();
Log.d("hello", "cost of Veg : "+mVegMeal.getCost());
mVegMeal.showItems();

Meal mChickenMeal = mb.prepareNonVegMeal();
Log.d("hello", "cost of Chicken : "+mChickenMeal.getCost());
mChickenMeal.showItems();

public class MealBuilder {
    public  Meal prepareVegMeal(){
        Meal meal = new Meal();
        meal.addItem(new VegBurger());
        meal.addItem(new Pepsi());
        return meal;
    }
    public Meal prepareNonVegMeal(){
        Meal meal = new Meal();
        meal.addItem(new ChickenBurger());
        meal.addItem(new Coke());
        return meal;
    }
}

public class Meal {

    private ArrayList items=new ArrayList();
    public void addItem(Item item){
        items.add(item);
    }
    public float getCost(){
        float cost = 0.0f;

        for (Item item:items) {
            cost += item.price();
        }

        return cost;
    }

    public void showItems(){
        StringBuilder sb = new StringBuilder();

        for (Item item: items
             ) {
            sb.append(item.name() + " ,");
        }
        Log.d("hello", "result :"+ sb.toString() );
    }
}

public interface Item {
    public abstract String name();
    public abstract Packing packing();
    public abstract float price();
}

public abstract class Burger implements Item {
    @Override
    public Packing packing(){
        return new Wrapper();
    }
}

public abstract class ColdDrink implements Item {

    @Override
    public Packing packing(){
        return new Bottle();
    }

}

interface Packing {
    public String pack();
}

public class Wrapper implements Packing {
    @Override
    public String pack() {
        return "Wrapper";
    }
}

public class Bottle implements Packing {
    @Override
    public String pack() {
        return "Bottle";
    }
}

public class Coke extends ColdDrink {
    @Override
    public String name() {
        return "Coke";
    }
    @Override
    public float price() {
        return 30.0f;
    }
}

public class Pepsi extends ColdDrink {
    @Override
    public String name() {
        return "Fake Coke";
    }


    @Override
    public float price() {
        return 35.0f;
    }
}
public class VegBurger extends Burger {

    @Override
    public String name() {
        return "Veg Burger";
    }

    @Override
    public float price() {
        return 25.0f;
    }
}
public class ChickenBurger extends Burger {
    @Override
    public String name() {
        return "Chicken Burger";
    }

    @Override
    public float price() {
        return 50.5f;
    }
}

-Singleton pattern은 가장 간단한 패턴중 하나 

-creational pattern에서 가장 좋은 객체 생성 방법 중 하나이다.

-이 패턴은 단일 class에 대해 인스턴스화 없이 오로지 하나의 객체만 생성하는 책임이 있다.

Implementation

- private 접근제어를 가지는 생성자를 가지며 해당 객체에 대한 인스턴스는 static으로 지정.

- 외부에는 객체를 전달하기 위한 static method를 제공한다.

	//Only way to get instance.
	SingleObject obj = SingleObject.getInstance();
	//SingleObject obj = new SingleObject(); //Compile cannot be done by access control
	obj.showMessage();

	
public class SingleObject {

    final static String TAG = SingleObject.class.getSimpleName();
    static private SingleObject instance = new SingleObject();
    private SingleObject(){}
    public static SingleObject getInstance(){
        return instance;
    }

    public void showMessage(){
        Log.d(TAG,"hello~");
    }
}