먹여살릴냥꽁이가있습니다.

이펙티브 자바를 공부하면서 플라이웨이트 패턴이 나와 개념 정리 및 실습을 해보려고 한다.

1. 플라이웨이트 패턴(Flyweight Pattern)이란?

동일하거나 유사한 객체들 사이에 가능한 많은 데이터를 서로 공유하여 사용하도록 하여 메모리 사용량을 최소화하는 디자인 패턴이다.

즉, 자주 변하는 속성과 변하지 않는 속성을 분리하고, 변하지 않는 속성은 재사용하여 메모리 사용을 줄이는 방식이다.

2. Flyweight Pattern의 구성

• Flyweight : 공유에 사용할 클래스
• FlyweightFactory : Flyweight 인스턴스를 생성 또는 공유
• Client : Flyweight : 해당 패턴의 사용자

3. 실습

• Shape (공유에 사용할 클래스들의 인터페이스)

public interface Shape {
	public void draw();
}

• Circle (인터페이스 내용 및 필요한 속성 정의)

public class Circle implements Shape {
	
	private String color;
	private int x;
	private int y;
	private int radius;
	
	public Circle(String color) {
		this.color = color;
	}

	public void setColor(String color) {
		this.color = color;
	}

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


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

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

	@Override
	public void draw() {
		System.out.println("Circle [color= " + color +" , x= "+ x + " , y= "+ y +" , radius= "+ radius + " ]" );
	}
}

• ShapeFactory (객체의 생성 또는 공유의 역할)

import java.util.HashMap;

public class ShapeFactory {
	public static final HashMap<String, Circle> circleMap = new HashMap<>();
	
	public static Shape getCircle(String color) {
		Circle circle = circleMap.get(color);
		
		if(circle == null) {
			circle = new Circle(color);
			circleMap.put(color, circle);
			System.out.println("---- 새로운 객체 생성 " + color +"색 원 ----" );
		}
		return circle;
	}
}

• Main 클래스

public class Main {

	public static void main(String[] args) {
		String[] colors = {"Red", "Yellow", "Pink", "Blue"};
		
		for(int i=0;i<10;i++) {
			Circle circle = (Circle) ShapeFactory.getCircle(colors[(int) (Math.random()*4)]);
			circle.setX((int) (Math.random()*10));
			circle.setY((int) (Math.random()*20));
			circle.setRadius((int) (Math.random()*10));
			circle.draw();
		}
	}
}

• 실행결과

---- 새로운 객체 생성 Blue색  ----
Circle [color= Blue , x= 8 , y= 5 , radius= 0 ]
---- 새로운 객체 생성 Red색  ----
Circle [color= Red , x= 5 , y= 5 , radius= 5 ]
---- 새로운 객체 생성 Pink색  ----
Circle [color= Pink , x= 6 , y= 17 , radius= 4 ]
Circle [color= Blue , x= 0 , y= 1 , radius= 6 ]
---- 새로운 객체 생성 Yellow색  ----
Circle [color= Yellow , x= 7 , y= 1 , radius= 4 ]
Circle [color= Yellow , x= 1 , y= 2 , radius= 0 ]
Circle [color= Red , x= 0 , y= 13 , radius= 3 ]
Circle [color= Yellow , x= 9 , y= 5 , radius= 1 ]
Circle [color= Pink , x= 1 , y= 16 , radius= 0 ]
Circle [color= Red , x= 7 , y= 11 , radius= 2 ]

같은 색상의 원은 1개만 생성되며, 생성된 객체를 공유하는 것을 확인할 수 있다.

4. 결론

4.1 언제 플라이웨이트 패턴을 사용하면 좋을까?

• 공통적인 인스턴스를 많이 생성하는 로직이 포함된 경우
• 자주 변하지 않는 속성을 재사용하는 경우

4.2 싱클톤 패턴과의 차이는 뭘까?

• 싱클톤 패턴은 클래스 자체가 오직 1개의 인스턴스만 허용
• 플라이웨이트 패턴은 싱글톤이 아닌 클래스 팩토리에서 제어

--> 인스턴스 생성의 제한을 어디서 제어하느냐의 차이

4.3 어디에서 플라이웨이트 패턴을 사용할까?

• 임베디드와 같이 메모리를 최소한으로 사용해야 하는 경우에 활용
• 클래스의 객체를 많이 만들어야할 때 사용

## 참고한 블로그 ##

1️⃣ Visitor Pattern

• 방문자와 방문 공간을 분리하여, 방문 공간이 방문자를 맞이할 때, 이후에 대한 행동을 방문자에게 위임하는 패턴
• 알고리즘을 객체 구조에서 분리시키는 디자인 패턴
  ⇒ 개방-폐쇄 원칙을 적용하는 방법 중 하나
  ⇒ 구조를 수정하지 않고도 실질적으로 새로운 동작을 기존의 객체 구조에 추가할 수 있게 된다.

예시

• 쇼핑몰 고객을 등급별로 나누고 등급에 따라 혜택을 주기로 한다.
• 등급은 Gold, Vip가 있고 혜택은 포인트, 할인이 있다.
• 고객 등급별 혜택을 줄 수 있는 확장 가능한 해결책을 찾아보자.

public interface Member { }

public class GoldMember implements Member { }

public class VipMember implements Member { }

• Member 인터페이스를 사용해서 등급별로 구체 클래스 생성

public class GoldMember implements Member {
	public void point() { System.out.println("Point for Gold Member"); }
	public void discount() { System.out.println("Discount for Gold Member"); }
}

public class VipMember implements Member {
	public void point() { System.out.println("Point for Vip Member"); }
	public void discount() { System.out.println("Discount for Vip Member"); }
}

• 등급별 혜택 구현

public class Main {
	public static void main(String[] args) {
		Member gold = new GoldMember();
		Member vip = new VipMember();

		gold.point();
		vip.point();
		gold.discount();
		vip.discount();
	}
}
//실행 결과
Point for Gold Member
Point for Vip Member
Discount for Gold Member
Discount for Vip Member

⭐ 문제점 ⭐

• 고객들에게 혜택을 주고자 할 때 명시적으로 혜택을 주기 위한 메소드를 호출해야한다.
• 혜택이 늘어났을 경우 모든 멤버들에 대해 그 혜택을 구현했다는 보장이 없다.

⭐ 해결방안 ⭐

public interface Benefit {
    void getBenefit(GoldMember member);
    void getBenefit(VipMember member);
}

• Benefit 인터페이스에 혜택을 받을 Member 별로 실행 가능한 메소드 정의

public class DiscountBenefit implements Benefit {
    @Override
    public void getBenefit(GoldMember member) {
        System.out.println("Discount for Gold Member");
    }

    @Override
    public void getBenefit(VipMember member) {
        System.out.println("Discount for Vip Member");
    }
}

public class PointBenefit implements Benefit {
    @Override
    public void getBenefit(GoldMember member) {
        System.out.println("Point for Gold Member");
    }

    @Override
    public void getBenefit(VipMember member) {
        System.out.println("Point for Vip Member");
    }
}

• 멤버 등급별 혜택에 대해 기능 구현

public interface Member {
    void getBenefit(Benefit benefit);
}

• 등급별 멤버가 혜택을 받을 수 있는 메소드를 Member 인터페이스에 선언

public class GoldMember implements Member {
    @Override
    public void getBenefit(Benefit benefit) {
        benefit.getBenefit(this);
    }
}

public class VipMember implements Member {
    @Override
    public void getBenefit(Benefit benefit) {
        benefit.getBenefit(this);
    }
}

• 혜택받는 메소드 구현
• 다른 Member가 추가되더라도 구현 부분은 benefit.getBenefit(Benefit benefit); 만 넣으면 된다.

public class Main {
    public static void main(String[] args) {
        Member goldMember = new GoldMember();
        Member vipMember = new VipMember();
        Benefit pointBenefit = new PointBenefit();
        Benefit discountBenefit = new DiscountBenefit();

        goldMember.getBenefit(pointBenefit);
        vipMember.getBenefit(pointBenefit);
        goldMember.getBenefit(discountBenefit);
        vipMember.getBenefit(discountBenefit);
    }
}

//실행 결과
Point for Gold Member
Point for Vip Member
Discount for Gold Member
Discount for Vip Member

⭐ 결과 ⭐

• Visitor 패턴에서는 혜택이 늘어나더라도 Benefit 인터페이스에 명시적으로 등급별 메소드를 정의하고 있어 구현 누락이 발생하지 않는다.
• 혜택을 추가하기 위해서 해당 혜택을 구현하는 클래스를 추가하면 되므로, 코드 중복이 발생하지 않는다.

⭐ Visitor 패턴을 언제 쓰면 좋을까? ⭐

• 대상 객체가 잘 바뀌지 않고, 적용할 알고리즘이 추가될 가능성이 많은 상황일 때

참고

https://thecodinglog.github.io/design/2019/10/29/visitor-pattern.html

https://velog.io/@cham/Design-Pattern-방문자-패턴-Visitor-pattern