easy blog

https://fumin.tistory.com/45

Observer pattern

-behavioral pattern 중 하나이다.

-객체간 1:N 관계일 경우 사용된다.

-하나의 객체가 변경되면 의존하는 객체들은 모두 자동으로 통지 받는다.

3개의 actor class로 구성된다.

Subject : client에 observer들을 attach 또는 detach 하는 역할.

Observer : subject에 등록되며 통지를 받음 통지내용은 update함수의 구현에 따라 다르다.

Client : 해당 예제에서는 Subject가 client 역할도 하는 것으로 보인다.

Main 호출 부분:

	Subject subject = new Subject();

	new HexaObserver(subject);
	new OctalObserver(subject);
	new BinaryObserver(subject);

	Log.d("hello","First state change :15");
	subject.setState(15);
	Log.d("hello","First state change :10");
	subject.setState(10);

public class Subject {
    private List observers = new ArrayList();
    private int state;
    public int getState() {
        return state;
    }

    public void setState(int state) {
        this.state = state;
        notifyAllObservers();
    }
    public void attach ( Observer observer){
        observers.add(observer);
    }

    public void notifyAllObservers() {
        for ( Observer o : observers){
            o.update();
        }
    }
}

public abstract class Observer {
    protected Subject subject;
    public abstract void update();
}

public class BinaryObserver extends Observer {

    public BinaryObserver(Subject subject){
        this.subject=subject;
        this.subject.attach(this);
    }

    @Override
    public void update() {
        Log.d("hello","Binary String : "+Integer.toBinaryString(subject.getState()));
    }
}

public class HexaObserver extends Observer {

    public HexaObserver(Subject subject){
        this.subject = subject;
        this.subject.attach(this);
    }

    @Override
    public void update() {
        Log.d("hello", "Hexa String : "+ Integer.toHexString(subject.getState()));
    }
}

public class OctalObserver extends Observer {

    public OctalObserver(Subject subject){
        this.subject=subject;
        this.subject.attach(this);
    }
    @Override
    public void update() {
        Log.d("hello", "Octal String : "+ Integer.toOctalString(subject.getState()));
    }
}

Memento pattern

-Memento -> 기념물

-behavioral pattern 중 하나

-이전 상태를 복구하기 위해 사용되는 패턴.

-3개의 actor class로 구성됨.

Memento : restore 위한 상태를 포함하는 객체

Originator : Memento객체로 state를 만들고 저장하는 객체.

CareTaker : Memento로 부터 객체 상태를 복구하는 역할.

Main 호출 부분:

        Originator originator = new Originator();
        CareTacker careTacker = new CareTacker();

        originator.setState("State #1");
        originator.setState("State #2");
        careTacker.add(originator.saveStateToMemento());


        originator.setState("Stage #3");
        careTacker.add(originator.saveStateToMemento());

        originator.setState("Stage #4");
        careTacker.add(originator.saveStateToMemento());

        originator.getStateFromMemento(careTacker.get(0));

        for (int i =0 ; careTracker.get(i)!=null;++i){
            originator.getStateFromMemento(careTacker.get(i));
            Log.d("hello","state :"+ originator.getState() );
        }

public class CareTacker {
    private List mementoList = new ArrayList<>();

    public void add ( Memento state){
        mementoList.add( state);
    }
    public Memento get(int index){
        return mementoList.get(index);
    }
}

public class Memento {
    private String state;
    public Memento( String state ){
        this.state=state;
    }
    
    public String getState() {
        return state;
    }
}

public class Originator {
    private String state;

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    public Memento saveStateToMemento(){
        return new Memento(state);
    }

    public void getStateFromMemento(Memento memento){
        state=memento.getState();
    }
}

Mediator pattern 

-behavioral pattern 에 속함.

-다수 객체와의 통신에서 복잡도를 낮추는데 사용됨.

-easy maintenance와 다른객체와의 통신을 loose coupling을 통해 다룬다.

예제에서 보이는 chat room은 모든 user에 대해 message를 출력하는 의무를 지닌다.

User들은 그들의 message를 공유하기 위해 showMessage를 이용한다.

Main 호출 부분:

        User ro = new User();
        ro.setName("Robert");
        User jo = new User();
        ro.setName("John");

        ro.sendMassage("hi~~~");
        jo.sendMassage("hello~~~");

public class ChatRoom {
    public static void showMessage(User user, String msg){
        Log.d("hello", "User :"+user.getName() +" msg : "+msg);
    }
}

public class User {

    private String name;
    public String getName(){
        return this.name;
    }
    public void setName(String name){
        this.name=name;
    }
    public void sendMassage(String msg){
        ChatRoom.showMessage(this, msg);
    }

}

Iterator Pattern

-collection으로 부터 요소에 대한 빠른 access를 얻기위해 사용하는 순차적인 방법으로 그 객체의 외형에 대해 알필요 없이 사용가능하다.

-behavioral pattern 중의 하나이다.

탐색방법을 설명할  iterator interface를 만든다.

Container interface는 iterator interface를 구현해야한다.

Main 호출 부분.

먼저 container를 구현한 collection에서 iterator 객체를 얻어온다.

그리고 Iterator객체로부터 얻고자 하는 객체를 collection의 element에 맞게 casting하여 사용한다.

        NameRepository nameRepository = new NameRepository();
        /*Iterator iterator = nameRepository.getIterator();


        for (String name = (String)iterator.next(); name!=null; name=(String)iterator.next()  ){
            Log.d("hello", "name : "+ name);
        }*/

        for (Iterator iterator=nameRepository.getIterator(); iterator.hasNext();)
        {
            String name=(String)iterator.next();
            Log.d("hello", "name : "+ name);
        }

public interface Iterator {
    public boolean hasNext();
    public Object next();
}

public interface Container {
    public Iterator getIterator();
}

public class NameRepository implements Container {
    public String names[] = {"Robert" , "John" ,"Julie" , "Lora"};

    @Override
    public Iterator getIterator() {
        return new NameIterator();
    }

    public class NameIterator implements Iterator {
        int index;

        @Override
        public boolean hasNext() {
            if(index < names.length)
                return true;
            return false;
        }

        @Override
        public Object next() {
            if ( hasNext() )
                return names[index++];
            return null;
        }
    }

	
	
}

Interpreter pattern

-grammar 또는 expression을 평가하는 pattern

-behavioral pattern 중 하나.

-expression interface을 구현하며 특정 context를 해석하는 역할을 한다.

-SQL parsing이나 symbol processing에 사용함.

Jone과 John이 다름을 구별해 내는데 성공함. 

filter pattern과 굉장히 유사하게 보인다.

Main 호출 부

    //Rule: Robert and John are male
    public static Expression getMaleExpression(){
        Expression robert = new TerminalExpression("Robert");
        Expression john = new TerminalExpression("Jone");
        return new OrExPression(robert,john);
    }

    //Rule: Julie is a married women
    public static Expression getMarriedWomanExpression(){
        Expression julie = new TerminalExpression("Julie");
        Expression married = new TerminalExpression("Married");
        return new AndExpression(julie, married);
    }

    public static void main(){
        Expression isMale = getMaleExpression();
        Expression isMarriedWoman = getMarriedWomanExpression();

        Log.d("hello", "John is male? ="+isMale.interpret("John"));
        Log.d("hello","Julie is married woman ? ="+isMarriedWoman.interpret("Married Julie"));
    }

public interface Expression {
    public boolean interpret(String context);
}

public class TerminalExpression implements Expression {

    private final String data;

    public TerminalExpression(String data){
        this.data=data;
    }

    @Override
    public boolean interpret(String context) {

        if (context.contains(data)){
            return true;
        }

        return false;
    }
}

public class AndExpression implements Expression {

    private final Expression exp1;
    private final Expression exp2;

    public AndExpression(Expression exp1, Expression exp2){
        this.exp1=exp1;
        this.exp2=exp2;
    }

    @Override
    public boolean interpret(String context) {
        return exp1.interpret(context) && exp2.interpret(context);
    }
}

public class OrExPression implements Expression {

    private final Expression exp1;
    private final Expression exp2;

    public OrExPression(Expression exp1, Expression exp2){
        this.exp1=exp1;
        this.exp2=exp2;
    }

    @Override
    public boolean interpret(String context) {
        return exp1.interpret(context)||exp2.interpret(context);
    }
}

Command pattern

-behavioral pattern에 속하며, data driven pattern이다.

-request는 command로 객체 안에 wrapping 되어 invoker 객체에 건내진다.

-invoker는 command를 다룰 수 있는 적절한 객체를 찾고 전달하여 command를 실행한다.

Order interface는 command로 사용하기 위해 만들어졌다.

Order는 command를 실제로 처리하는 역할

Stock은 request로써 만들어지며, Order에 wrapping된다.

Broker는 Invoker로써 동작하여 명령을 내리는데 사용된다.

	//make a request
	Stock abcStock=new Stock();
	//make commands
	Order buy = new BuyStock(abcStock);
	Order sell = new SellStock(abcStock);
	Broker broker =new Broker();

	//pass commands to invoker
	broker.takeOrder(buy);
	broker.takeOrder(sell);

	//execution
	broker.placeOrders();

/**
 * request class
 */
public class Stock {
    public static String TAG = "Stock";
    private String name ="ABC";
    private int quantity = 10;

    public void buy(){
        Log.d(TAG, "Stock [ Name: "+name+", Quantity: " + quantity +" ] bought");
    }
    public void sell(){
        Log.d(TAG, "Stock [ Name: "+name+", Quantity: " + quantity +" ] sold");
    }
}

/**
 * Invoker class
 */
public class Broker {
    private List  orderList = new ArrayList();

    public void takeOrder(Order order){
        orderList.add(order);
    }
    public void placeOrders(){

        for ( Order o : orderList){
            o.execute();
        }
        orderList.clear();
    }
}

public interface Order {
    void execute();
}

public class SellStock implements Order {

    private final Stock abcStock;

    SellStock(Stock abcStock){
        this.abcStock=abcStock;
    }

    @Override
    public void execute() {
        abcStock.sell();
    }
}

public class BuyStock implements Order {

    private final Stock abcStock;

    public BuyStock(Stock abcStock){
        this.abcStock=abcStock;
    }

    @Override
    public void execute() {
        abcStock.buy();
    }
}

결과:

07-20 17:22:27.275 16908 16908 D Stock   : Stock [ Name: ABC, Quantity: 10 ] bought

07-20 17:22:27.275 16908 16908 D Stock   : Stock [ Name: ABC, Quantity: 10 ] sold

출처 :

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

Chain of Responsibility Pattern

-behavioral pattern

-request를 처리하는 객체들을 만든다.

-request type에 기반하여 sender와 receiver을 decouple한다.

-receiver는 또다른 receiver에 대한 reference를 가지며, 만일 해당객체가 request를 처리하지 못하면 다음 receiver에 전달하는 구조이다.

log message의 레벨은 해당 Logger가 가지는 level보다 작거나 같아야만 메시지를 출력 가능하다.

결과에서 보이듯 ERROR 레벨에서는 DEBUG 및 INFO 메시지를 출력할 수 없다.

Logger에 대한 set은 getChainOfLoggers에서 진행한다.

AbstractLogger.java

public abstract class AbstractLogger {
    public static int INFO  = 1;
    public static int DEBUG = 2;
    public static int ERROR = 3;
    public final static String TAG = "logger";
    protected int level;

    protected AbstractLogger nextLogger;

    public void setNextLogger(AbstractLogger nextLogger){
        this.nextLogger=nextLogger;
    }

    public void logMessage(int level, String msg){
        if( this.level <= level){
            write(msg);
        }
        if (nextLogger != null) {
            nextLogger.logMessage(level,msg);
        }
    }
    abstract protected void write (String msg);
}

public class ChainPatternDemo {

    public static AbstractLogger getChainOfLoggers(){

        AbstractLogger errorLogger = new ErrorLogger(AbstractLogger.ERROR);
        AbstractLogger fileLogger = new FileLogger(AbstractLogger.DEBUG);
        AbstractLogger consolLogger = new ConsoleLogger(AbstractLogger.INFO);

        errorLogger.setNextLogger(fileLogger);
        fileLogger.setNextLogger(consolLogger);

        return errorLogger;
    }

    public static void main(){
        AbstractLogger loggerChain = getChainOfLoggers();

        loggerChain.logMessage(AbstractLogger.INFO,"this is info");
        loggerChain.logMessage(AbstractLogger.DEBUG,"this is debug");
        loggerChain.logMessage(AbstractLogger.ERROR,"this is error");
    }
}

public class ConsoleLogger extends AbstractLogger {

    public ConsoleLogger(int level){
        this.level=level;
    }

    @Override
    protected void write(String msg) {
        Log.d(TAG, "console :" + msg);
    }
}

public class ErrorLogger extends AbstractLogger {

    public ErrorLogger(int level){
        this.level=level;
    }
    @Override
    protected void write(String msg) {
        Log.d(TAG, "error :" + msg);
    }
}

public class FileLogger extends AbstractLogger {

    public FileLogger(int level){
        this.level=level;

    }
    @Override
    protected void write(String msg) {
        Log.d(TAG, "file :" + msg);
    }
}

결과:

07-20 15:27:17.084 14846 14846 D logger  : console :this is info

07-20 15:27:17.084 14846 14846 D logger  : file :this is debug

07-20 15:27:17.084 14846 14846 D logger  : console :this is debug

07-20 15:27:17.084 14846 14846 D logger  : error :this is error

07-20 15:27:17.085 14846 14846 D logger  : file :this is error

07-20 15:27:17.085 14846 14846 D logger  : console :this is error

출처 :

https://www.tutorialspoint.com/design_pattern/chain_of_responsibility_pattern.html

Proxy Pattern

-structual pattern의 하나로, 다른 class의 기능을 담당하는 또다른 class

-outer world에 본래 객체의 기능전달을 위한 interface를 가진 객체를 만든다.

ProxyImage는 RealImage를 field로 가진다.(original object)

ProxyImage는 Image 와 공통의 interface를 구현함으로써 RealImage의 존재를 가리고 기능을 대신 제공한다.

client 오직 proxy와 대화하며 loadFromDisk와 같은 부차적인 작업에 신경쓸 필요가 없다.

ProxyImage.java

public class ProxyImage implements Image {
    private String fileName;
    RealImage realImage;

    public ProxyImage(String fileName){
        this.fileName = fileName;
    }
    @Override
    public void display() {
        if(realImage==null){
            realImage=new RealImage(fileName);
        }
        realImage.display();
    }
}

public class RealImage implements Image {
    private String fileName;


    RealImage(String fileName){
        this.fileName=fileName;
        loadFromDisk(fileName);
    }

    private void loadFromDisk(String fileName) {
        Log.d(TAG, "Loading :" +fileName);
    }

    @Override
    public void display() {
        Log.d(TAG, "display :" +fileName);
    }

}

Image.java

public interface Image {
    public static final String TAG = "Image";
    void display();
}

결과 : 

07-20 14:42:45.132 13017 13017 D Image   : Loading :SimpleFile.png

07-20 14:42:45.133 13017 13017 D Image   : display :SimpleFile.png

07-20 14:42:45.133 13017 13017 D Image   : display :SimpleFile.png

출처 : 

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

Flyweight pattern

-생성되는 객체의 수를 감소시키고, 메모리 사용량을 감소시켜 performance를 증대 시킴.

-객체 구조를 향상시키고 갯수를 감소시키는 structural pattern.

-이미 존재하는 유사한 객체를 저장하고 재사용함, 만일 매칭되는 객체가 없을 경우에 객체를 생성함.

Main 호출 부

	Circle s = (Circle) ShapeFactory.getCircle("red");

	s.setRadius(10);
	s.setX(10);
	s.setY(10);
	s.draw();

	s=(Circle)ShapeFactory.getCircle("green");

	s.setRadius(9);
	s.setX(9);
	s.setY(9);
	s.draw();

	s=(Circle)ShapeFactory.getCircle("blue");
	
	s.setRadius(11);
	s.setX(11);
	s.setY(11);
	s.draw();

	s=(Circle)ShapeFactory.getCircle("red");
	s.draw();
	s=(Circle)ShapeFactory.getCircle("green");
	s.draw();
	s=(Circle)ShapeFactory.getCircle("blue");
	s.draw();

public class ShapeFactory  {

    private static HashMap CircleMap = new HashMap();
    public static Shape getCircle(String color){
        Circle circle = (Circle)CircleMap.get(color);

        if (circle == null){
            circle = new Circle(color);
            CircleMap.put(color, circle);
            Log.d("shape", "Create circle : color ="+color);

        }
        return circle;
    }
}

public interface Shape {
    void draw();
}

public class Circle implements Shape {
    private String color;
    private int x;
    private int y;
    private int radius;


    public Circle(String color){
        this.color=color;
    }


    private final String TAG = Circle.class.getSimpleName();
    @Override
    public void draw() {
        Log.d(TAG, "Circle color ="+color+" x :"+x+" y :"+y + " radius : "+radius);
    }

    public void setX(int x) {
        this.x = x;
    }

    public void setY(int y) {
        this.y = y;
    }

    public void setRadius(int radius) {
        this.radius = radius;
    }
}