[GoF 디자인패턴] 인터프리터 (Interpreter) 패턴

[leeyuunsung]

인터프리터 패턴 1부 - 패턴 소개

• 자주 등장하는 문제를 간단한 언어로 정의하고 재사용하는 패턴
• CS 에서의 '인터프리터' 는 사람이 작성한 코드를 기계가 이해하기 쉬운 형태로 변환해주는 장치(ex. 컴파일러) 를 의미함
• 보다 근본이 되는 개념으로 원본에 대해 다른 형태로 바꿔주는 역할
• 인터프리터 패턴을 사용하여 반복되는 문제 패턴을 언어 또는 문법으로 정의하고 확장할 수 있다
• 정규표현식 이 일종의 인터프리터 라고 볼 수 있다

예시

참고

• 1 + 2 - 5 와 같이 부호가 숫자 중간에 위치한 형태는 infix 에 해당
• 1 2 + 5 - 와 같이 부호가 숫자 오른쪽에 위치한 형태는 postfix 에 해당
• 123+- 의 경우 부호가 위치한 경우 앞의 두 숫자를 연산
• 1(23+)- -> 15- -> -4

public class PostfixNotation {

    private final String expression;

    public PostfixNotation(String expression) {
        this.expression = expression;
    }

    public static void main(String[] args) {
        PostfixNotation postfixNotation = new PostfixNotation("123+-");
        postfixNotation.calculate();
    }

    private void calculate() {
        Stack<Integer> numbers = new Stack<>();

        for (char c : this.expression.toCharArray()) {
            switch (c) {
                case '+':
                    numbers.push(numbers.pop() + numbers.pop());
                    break;
                case '-':
                    int right = numbers.pop();
                    int left = numbers.pop();
                    numbers.push(left - right);
                    break;
                default:
                    numbers.push(Integer.parseInt(c + ""));
            }
        }

        System.out.println(numbers.pop());
    }
}

스택을 사용하여 postfix 를 연산하는 예시

• 위 예제의 expression 123+- 과 같이 xyz+- 패턴을 자주 사용하는 경우, DSL(Domain Specific Language) 로써 등록하고 정의하여 사용할 수 있다

인터프리터 패턴 아키텍처

• Expression : 실질적인 문법을 나타냄(xyz+-)
  • TerminalExpression : 그 자체로 종료가 되는 Expression(xyz)
  • NonTerminalExpression : 종료가 되지 않고 다른 Terminal/NonTerminal Expression 들을 재귀적으로 참조하고 있는 Expression(+-)
• Context : 모든 Expression 에서 사용하는 공통된 정보가 들어있는 곳(global 한 값들이 모여있는 곳)
• 위 Expression 의 아키텍처는 Abstraction Syntax Tree 형태를 이고, 컴포짓 패턴과 유사함

[leeyuunsung]

인터프리터 패턴 2부 - 패턴 적용하기

App

public class App {

    public static void main(String[] args) {
        PostfixExpression expression = PostfixParser.parse("xyz+-a+");
        int result = expression.interpret(Map.of('x', 1, 'y', 2, 'z', 3, 'a', 4));
        System.out.println(result);
    }
}

PostfixExpression

public interface PostfixExpression {

    int interpret(Map<Character, Integer> context);

}

VariableExpression

public class VariableExpression implements PostfixExpression {

    private Character character;

    public VariableExpression(Character character) {
        this.character = character;
    }

    @Override
    public int interpret(Map<Character, Integer> context) {
        return context.get(this.character);
    }
}

PlusExpression

public class PlusExpression implements PostfixExpression {

    private PostfixExpression left;

    private PostfixExpression right;

    public PlusExpression(PostfixExpression left, PostfixExpression right) {
        this.left = left;
        this.right = right;
    }

    @Override
    public int interpret(Map<Character, Integer> context) {
        return left.interpret(context) + right.interpret(context);
    }
}

PostfixParser

public class PostfixParser {

    public static PostfixExpression parse(String expression) {
        Stack<PostfixExpression> stack = new Stack<>();
        for (char c : expression.toCharArray()) {
            stack.push(getExpression(c, stack));
        }
        return stack.pop();
    }

    private static PostfixExpression getExpression(char c, Stack<PostfixExpression> stack) {
        switch (c) {
            case '+':
                return new PlusExpression(stack.pop(), stack.pop());
            case '-':
                PostfixExpression right = stack.pop();
                PostfixExpression left = stack.pop();
                return new MinusExpression(left, right);
            default:
                return new VariableExpression(c);
        }
    }
}

Java8 이상부터 가능한 interface 내 static method 적용

PostfixExpression

public interface PostfixExpression {

    int interpret(Map<Character, Integer> context);

    static PostfixExpression plus(PostfixExpression left, PostfixExpression right) {
        return context -> left.interpret(context) + right.interpret(context);
    }
    static PostfixExpression minus(PostfixExpression left, PostfixExpression right) {
        return context -> left.interpret(context) - right.interpret(context);
    }
    static PostfixExpression variable(Character c) {
        return context -> context.get(c);
    }
}

PostfixParser

public class PostfixParser {

    public static PostfixExpression parse(String expression) {
        Stack<PostfixExpression> stack = new Stack<>();
        for (char c : expression.toCharArray()) {
            stack.push(getExpression(c, stack));
        }
        return stack.pop();
    }

    private static PostfixExpression getExpression(char c, Stack<PostfixExpression> stack) {
        switch (c) {
            case '+':
                return plus(stack.pop(), stack.pop());
            case '-':
                PostfixExpression right = stack.pop();
                PostfixExpression left = stack.pop();
                return minus(left, right);
            default:
                return variable(c);
        }
    }
}

[leeyuunsung]

인터프리터 패턴 3부 - 장점과 단점

• 요청을 캡슐화 하여 호출자(invoker)와 수신자(receiver)를 분리하는 패턴

장점

• 자주 등장하는 문제 패턴을 언어와 문법으로 정의할 수 있다
• 기존 코드를 변경하지 않고 새로운 Expression을 추가할 수 있다

  단점

• 복잡한 문법을 표현하려면 Expression과 Parser가 복잡해진다

[leeyuunsung]

인터프리터 패턴 4부 - 자바와 스프링에서 찾아보는 패턴

자바

• 자바 컴파일러
• 정규 표현식

  스프링

• SpEL (스프링 Expression Language)