더블 디스패치(Double Dispatch) 와 방문자 패턴(Visitor Pattren)

🔍 더블 디스패치(Double Dispatch)

더블 디스패치는 Dynamic Dispatch를 두 번 하는 것을 의미한다.

 

 

situation

우주선을 행성에 착륙시키는 상황

우주선을 행성에 착륙시키는 로직을 작성하세요

 

public interface Planet {
}

public class Mercury implements Planet {
}

public class Venus implements Planet {
}

public class Earth implements Planet {
}


public interface SpaceShip {
    void landing(Planet planet);
    void landing(Mercury planet);
    void landing(Venus planet);
    void landing(Earth planet);
}

 

 각각의 행성들을 만들고 spaceship 인터페이스에서 landing메소드를 행성마다 오버로딩 했다.

각 행성은 착륙방식을 다르게 설계해야 하기 때문이다.

이제 위 인터페이스를 바탕으로 탐사선을 만들어 보자

 

public class UkSpaceShip implements SpaceShip{

    @Override
    public void landing(Planet planet) {
        System.out.println("기본 착륙 방식");

    }

    @Override
    public void landing(Mercury planet) {
        System.out.println("낙하 장비를 펼칩니다.");
        System.out.println("밑으로 공기를 뿜습니다.");
        System.out.println("수성 착륙.");
    }

    @Override
    public void landing(Venus planet) {
        System.out.println("낙하산을 펼칩니다.");
        System.out.println("금성 착륙");

    }

    @Override
    public void landing(Earth planet) {
        System.out.println("낙하 장치를 펼칩니다.");
        System.out.println("속도가 줄어들면 운전석이 분리됩니다.");
        System.out.println("물에 떨어지길 기도합니다.");
        System.out.println("지구 착륙.");
    }
}

 

이제 만들어진 탐사선을 Main함수를 통해 착륙시켜보자

 

import java.util.ArrayList;
import java.util.List;
import org.example.planet.Earth;
import org.example.planet.Mercury;
import org.example.planet.Planet;
import org.example.planet.Venus;

public class Main {
    public static void main(String[] args) {
        SpaceShip ship = new UkSpaceShip();
        // Mercury, Venus, Earch 인스턴스를 planets에 추가한다.
        List<Planet> planets = new ArrayList<>();
        planets.add(new Mercury());
        planets.add(new Venus());
        planets.add(new Earth());
		
        // 각각의 행성에 UkSpaceShip 인스턴스를 landing한다.
        for (Planet planet : planets) {
            ship.landing(planet);
        }
    }
}

 

 

결과는? 

 

분명 행성마다 착륙 로직을 다르게 작성했는데 전부 기본 로직으로 동작하고 있다.

 

왜냐하면 ship.landing(planet) 에서 파라미터로 넘겨준 planet은 planet 타입의 객체이기 때문이다 planet을 Mercury, Venus, Earth가 구현하고 있지마 자바의 입장에서는 이를 알 수 없기 때문에 위와같이 기본 로직이 실행된 것이다.

 

이와같은 문제를 해결할 수 있는 방법으로 2가지 방법이 있다.

 

 

💡방법 1 - planet 객체가 각 행성의 인스턴스인지 확인하기

public class Main {
    public static void main(String[] args) {
        SpaceShip ship = new UkSpaceShip();
        List<Planet> planets = new ArrayList<>();
        planets.add(new Mercury());
        planets.add(new Venus());
        planets.add(new Earth());

        for (Planet planet : planets) {
        	if (planet instanceof Mercury) {
				ship.landing((Mercury) planet);
            } else if (planet instanceof Venus) {
            ... 생략
            }
        }
    }
}

 

하지만 위와같이 코드를 작성하면 새로운 행성객체를 만들었을 때 수정을 해야할 뿐더러 코드의 양이 많아지는 순간 헷갈리는 문제점이 생긴다.

 

💡방법 2 - Double Dispatch

 

public interface Planet {
	// 추상메서드가 추가되었습니다.
    void landed(SpaceShip spaceShip);

}
import org.example.SpaceShip;

public class Mercury implements Planet {
    @Override
    public void landed(SpaceShip spaceShip) {
        spaceShip.landing(this);
    }
}


import org.example.SpaceShip;

public class Venus implements Planet {
    @Override
    public void landed(SpaceShip spaceShip) {
        spaceShip.landing(this);
    }
}


import org.example.SpaceShip;

public class Earth implements Planet {
    @Override
    public void landed(SpaceShip spaceShip) {
        spaceShip.landing(this);
    }
}


import java.util.ArrayList;
import java.util.List;
import org.example.planet.Earth;
import org.example.planet.Mercury;
import org.example.planet.Planet;
import org.example.planet.Venus;

public class Main {
    public static void main(String[] args) {
        SpaceShip ship = new UkSpaceShip();
        List<Planet> planets = new ArrayList<>();
        planets.add(new Mercury());
        planets.add(new Venus());
        planets.add(new Earth());

        for (Planet planet : planets) {
//            ship.landing(planet);

			// 해당 코드가 추가되었습니다
            planet.landed(ship);
            System.out.println("\n");
        }
    }
}

 

 

결과는?

 

 

위와같이 각 행성별로 로직이 실행되는 것을 볼 수 있다.

 

수정 전 구조와 더블 디스패치를 사용한 구조를 비교해보면

 

수정 전 구조

더블 디스패치로 수정한 구조

 

 

자바에서 파라미터로 인터페이스 형태를 넘겨주게 되면 내부에서 instanceOf 메소드를 통해 컨버팅을 해줘야만 한다.

때문에 planet 구현체에서 landed라는 메소드를 만들어주고 landed메소드에서 SpaceShip  객체의 landing메소드를 호출하면서 this라는 각각의 행성을 구현체로 넘겨준다.

 

이러한 방식을 Double Dispatch라고 한다.

 

이런식으로 구조를 가져가면

 

newSpaceShip이라는 새로운 클래스를 만들었을 때도 수정할 필요가 없이 클래스만 갈아끼우면 된다.

 

import org.example.planet.Earth;
import org.example.planet.Mercury;
import org.example.planet.Planet;
import org.example.planet.Venus;

public class NewSpaceShip implements SpaceShip {

    @Override
    public void landing(Planet planet) {
        System.out.println("기본 착륙 방식");
    }

    @Override
    public void landing(Mercury planet) {
        System.out.println("기술발전으로 그냥 착륙합니다");
        System.out.println("수성 착륙");
    }

    @Override
    public void landing(Venus planet) {
        System.out.println("기술발전으로 그냥 착륙합니다");
        System.out.println("금성 착륙");

    }

    @Override
    public void landing(Earth planet) {
        System.out.println("지구 착륙");
    }
}
public class Main {
    public static void main(String[] args) {
//        SpaceShip ship = new UkSpaceShip();
        SpaceShip ship = new NewSpaceShip();

        List<Planet> planets = new ArrayList<>();
        planets.add(new Mercury());
        planets.add(new Venus());
        planets.add(new Earth());

        for (Planet planet : planets) {
            planet.landed(ship);
            System.out.println("\n");
        }
    }
}

 

 

Planet이 바뀌지 않는다는 전제하에 탐사선 클래스를 얼마든지 변경해도 문제가 생기지 않는다. 이를 통해 OCP 원칙을 지킬 수 있다.

 

 

 

 

🔍 방문자 패턴(Visitor Pattern)

방문자 패턴(Visitor Pattern)은 객체 지향 프로그래밍에서 사용되는 디자인 패턴 중 하나로 객체의 구조와 그 구조에서 수행되는 작업을 분리하여 구현하는 패턴이다.

객체의 구조와 구조에서 수행되는 작업을 분리하여 구현함으로써 객체의 확장성과 유연성을 높이는며 개방-폐쇠(OCP)원칙을 적용하는 방법 중 한가지이다.

 

 

Visitor 패턴 예제

자바에서 방문자 패턴을 구현하기 위해서는 다음과 같은 요소들이 필요하다.

 

1.  Element(요소) 인터페이스 : 방문자가 방문할 객체들의 공통 인터페이스이다. accept메소드를 가지고 있어서, 방문자가 자신을 방문할 수 있도록 한다.
2. ConcreteElement(구체적인 요소) 클래스 : Element 인터페이스를 구현한 클래스들이다. 방문자가 방문할 실제 객체들 
3. Visitor(방문자) 인터페이스 : Element 객체들을 방문하는 메소드들을 선언한 인터페이스이다.
4. ConcreteVisitor(구체적인 방문자) 클래스 : Visitor 인터페이스를 구현한 클래스들이다. Element 객체들을 방문하는 구체적인 방법들을 구현한다.

 

위의 다이어그램을 코드로 구현한 예제를 살펴보자

public interface Visitor {
    int visit(Book book);
    int visit(Music music);
    int visit(Movie movie);
}

 

먼저, 방문자(Visitor) 인터페이스를 정의해준다. 이 인터페이스는 각각의 상품 클래스에서 구현될 visit 메소드를 정의한다.

public interface Element {
    int accept(Visitor visitor);
}

 

각각의 Element 상품 클래스(Book, Music, Movie)를 정의한다. 각 클래스는 가격(price) 속성을 갖고 있으며, Visitor인터페이스에서 구현한 visit 메소드를 정의한다.

public class Book implements Element {
    private int price;

    public Book(int price) {
        this.price = price;
    }

    public int getPrice() {
        return price;
    }

    @Override
    public int accept(Visitor visitor) {
        return visitor.visit(this);
    }
}

public class Music implements Element {
    private int price;

    public Music(int price) {
        this.price = price;
    }

    public int getPrice() {
        return price;
    }

    @Override
    public int accept(Visitor visitor) {
        return visitor.visit(this);
    }
}

public class Movie implements Element {
    private int price;

    public Movie(int price) {
        this.price = price;
    }

    public int getPrice() {
        return price;
    }

    @Override
    public int accept(Visitor visitor) {
        return visitor.visit(this);
    }
}

 

public class PriceCalculator implements Visitor {

    @Override
    public int visit(Book book) {
        return book.getPrice();
    }

    @Override
    public int visit(Music music) {
        return music.getPrice() * 2;
    }

    @Override
    public int visit(Movie movie) {
        return movie.getPrice() * 3;
    }
}

 

Visitor 인터페이스를 구현한 가격 계산 Visitor 클래스를 정의한다. 이 클래스는 각각의 상품을 방문하여 가격을 계산한다.

public class Main {
    public static void main(String[] args) {
        Element book = new Book(10000);
        Element music = new Music(5000);
        Element movie = new Movie(15000);

        Visitor visitor = new PriceCalculator();

        int totalPrice = book.accept(visitor) + music.accept(visitor) + movie.accept(visitor);

        System.out.println("book pirce = " + book.accept(visitor));
        System.out.println("music pirce = " + music.accept(visitor));
        System.out.println("movie pirce = " + movie.accept(visitor));
        System.out.println("Total Price = " + totalPrice);

    }
}

 

 

실행결과는?

 

Book, Music, Movie 클래스의 인스턴스를 생성하고, PriceCalculator클래스의 인스턴스를 생성한다. 각각의 상품 인스턴스에서는 accept 메소드를 호출하여 PriceCalculator 클래스의 visit 메소드를 호출한다.

이런식으로 Visitor 패턴을 사용하면, 새로운 상품이 추가될 때마다, 객체 구조를 수정하지 않고도 PriceCalculator 클래스의 visit 메소드를 추가하거나 수정함으로써 가격 계산 방식을 변경할 수 있다.

 

 

 

 

references

https://shan0325.tistory.com/41

https://velog.io/@iamtaehoon/y3uuyvw5