01. 싱글톤 (Singleton) 패턴
- 인스턴스를 오직 한개만 제공하는 패턴
구현 방법 1
- private 생성자에 static 메소드
- 멀티쓰레드 환경에서 안전하지 않음 (여러 쓰레드가 동시에 접근할 경우 여러 인스턴스가 생길수 있다)
public class Settings {
private static Settings instance;
private Settings() {
// 외부에서 생성하지 못하게 private 으로 지정
}
public static Settings getInstance() {
if (instance == null) {
instance = new Settings();
}
return instance;
}
}구현 방법 2
- 동기화(synchronized)를 사용해 멀티쓰레드 환경에서 안전하게 만드는 방법
- synchronized 특성상 성능이슈가 생길수있다.
public static synchronized Settings getInstance() {
if (instance == null) {
instance = new Settings();
}
return instance;
}구현 방법 3
- 이른 초기화 (eager initialization)을 사용하는 방법
- Thread safe 하다.
- 클래스 로딩 시점에 static field 가 초기화 되므로 객체 생성비용이 클 경우 단점이 될 수 있다.
private static final Settings INSTANCE = new Settings();
private Settings() {
}
public static Settings getInstance() {
return INSTANCE;
}구현 방법 4
- double-checked locking
- volatile 키워드를 이용해서 캐시 불일치 이슈를 방지 할 수 있다. (java 1.5 이상)
- 필드에 instance 가 할당되지 않았을 경우에만 synchronized 블록을 실행하므로
메서드에 synchronized 처리를 하는것보다 성능상 유리하다. - instance 가 필요한 시점에 만들수 있다.
public class Settings {
private static volatile Settings instance;
private Settings() {
}
public static Settings getInstance() {
if (instance == null) {
synchronized (Settings.class) {
if (instance == null) {
instance = new Settings();
}
}
}
return instance;
}
}구현 방법 5
- static nested 클래스를 사용하는 방법 (Initialization-on-demand holder)
- 클래스안에 클래스(Holder)를 두어 JVM 의 Class Loader 매커니즘과 Class 가 로드되는 시점을 이용한 방법
- Settings 클래스에는 Holder 클래스의 필드가 없기 때문에 Settings 클래스 로딩 시 Holder 클래스를 초기화하지 않음
- Lazy initialization 방식을 가져가면서 Thread 간 동기화 문제를 동시에 해결 가능
public class Settings {
private static Settings instance;
private static class SettingsHolder {
private static final Settings SETTINGS = new Settings();
}
public static Settings getInstance() {
return SettingsHolder.SETTINGS;
}
}구현 방법 6
- enum 을 사용하는 방법
- enum 은 상수 하나당 인스턴스가 만들어지며, 각각 public static final 로 공개한다.
- 리플렉션을 통해 싱글톤을 깨트리는 공격에 안전하며, 직렬화를 보장한다.
public enum Settings {
INSTANCE
}싱글톤 패턴을 깨트리는 방법
리플렉션 사용
Settings settings = Settings.getInstance();
Constructor<Settings> declaredConstructor = Settings.class.getDeclaredConstructor();
declaredConstructor.setAccessible(true);
Settings settings1 = declaredConstructor.newInstance();
System.out.println(settings == settings1); // false직렬화 & 역직렬화 사용
Settings settings = Settings.getInstance();
Settings settings1 = null;
try (ObjectOutput out = new ObjectOutputStream(new FileOutputStream("settings.obj"))) {
out.writeObject(settings);
}
try (ObjectInput in = new ObjectInputStream(new FileInputStream("settings.obj"))) {
settings1 = (Settings) in.readObject();
}
System.out.println(settings == settings1); // false02. 팩토리 메소드 (Factory Method) 패턴
- 구체적으로 어떤 인스턴스를 만들지는 서브 클래스가 정하는 패턴
- 다양한 구현체 (Product)가 있고, 그중에서 특정한 구현체를 만들 수 있는 다양한 팩토리 (Creator)를 제공할 수 있다.
- 팩토리들은 객체의 인스턴스를 생성하는 부분을 캡슐화 하기 위해 사용된다.
구현 방법
// Product
public interface Pizza {
void prepare();
void bake();
void box();
}
// ConcreteProduct
public class NYStyleCheesePizza implements Pizza { ... }
public class NYStylePepperoniPizza implements Pizza { ... }
public class ChicagoStyleCheesePizza implements Pizza { ... }
public class ChicagoStylePepperoniPizza implements Pizza { ... }// Creator
public interface PizzaStore {
default Pizza orderPizza(String type) {
Pizza pizza = createPizza(type);
pizza.prepare();
pizza.bake();
pizza.box();
return pizza;
}
// factory method
Pizza createPizza(String type);
}// ConcreteCreator 1
public class NYPizzaStore extends PizzaStore {
@Override
public Pizza createPizza(String type) {
if ("cheese".equals(type)) {
return new NYStyleCheesePizza();
}
if ("pepperoni".equals(type)) {
return new NYStylePepperoniPizza();
}
throw new IllegalArgumentException();
}
}
// ConcreteCreator 2
public class ChicagoPizzaStore extends PizzaStore {
@Override
public Pizza createPizza(String type) {
if ("cheese".equals(type)) {
return new ChicagoStyleCheesePizza();
}
if ("pepperoni".equals(type)) {
return new ChicagoStylePepperoniPizza();
}
throw new IllegalArgumentException();
}
}public static void main(String[] args) {
PizzaStore nyStore = new NYPizzaStore();
PizzaStore chicagoStore = new ChicagoPizzaStore();
Pizza pizza = nyStore.orderPizza("cheese");
Pizza pizza1 = chicagoStore.orderPizza("pepperoni");
}Simple Factory
- 객체를 생성하는 역할을 하나의 팩토리 클래스가 전담하게 하는 방법.
- 주어진 입력을 기반으로 다른 유형의 객체를 리턴하는 메소드가 있는 팩토리 클래스.
- 디자인 패턴이라기 보다는 자주 사용되는 프로그래밍 기법으로 보면 된다.
public class PizzaFactory {
public static Pizza createPizza(String type) {
if ("cheese".equals(type)) {
return new CheesePizza();
}
if ("pepperoni".equals(type)) {
return new PepperoniPizza();
}
throw new IllegalArgumentException();
}
}03. 추상 팩토리 (Abstract Factory) 패턴
- 서로 연관되거나 의존적인 객체들의 조합을 만드는 인터페이스를 제공하는 패턴
- 구체적으로 어떤 클래스의 인스턴스를(concrete product)를 사용하는지 감출 수 있다.
구현 방법
// Product
public interface Frame {
void shape();
}
public interface Wheel {
void size();
}
// ConcreteProduct
public class AFrame implements Frame { ... }
public class BFrame implements Frame { ... }
public class AWheel implements Wheel { ... }
public class BWheel implements Wheel { ... }// AbstractFactory
public interface CarFactory {
Frame createFrame();
Wheel createWheel();
}
// ConcreteFactory 1
public class ACarFactory implements CarFactory {
@Override
public Frame createFrame() {
return new AFrame();
}
@Override
public Wheel createWheel() {
return new AWheel();
}
}
// ConcreteFactory 2
public class BCarFactory implements CarFactory {
@Override
public Frame createFrame() {
return new BFrame();
}
@Override
public Wheel createWheel() {
return new BWheel();
}
}// Client 에서 사용할 대상
public class Car {
private Frame frame;
private Wheel wheel;
public Car(Frame frame, Wheel wheel) {
this.frame = frame;
this.wheel = wheel;
}
public Frame getFrame() {
return frame;
}
public Wheel getWheel() {
return wheel;
}
}// Client
public class Client {
private CarFactory carFactory;
public Client(CarFactory carFactory) {
this.carFactory = carFactory;
}
public Car createCar() {
return new Car(carFactory.createFrame(), carFactory.createWheel());
}
}public static void main(String[] args) {
Car car = new Client(new ACarFactory());
System.out.println(car.getFrame().getClass());
System.out.println(car.getWheel().getClass());
Car car2 = new Client(new BCarFactory());
System.out.println(car2.getFrame().getClass());
System.out.println(car2.getWheel().getClass());
}팩토리 메소드 패턴 vs 추상 팩토리 패턴
관점
- 팩토리 메소드 패턴은 "팩토리를 구현하는 방법 (inheritance)" 에 초점을 둔다.
- 추상 팩토리 패턴은 "팩토리를 사용하는 방법 (composition)" 에 초점을 둔다.
목적
- 팩토리 메소드 패턴은 구체적인 객체 생성 과정을 하위 또는 구체적인 클래스로 옮기는 것이 목적.
- 추상 팩토리 패턴은 관련있는 여러 객체를 구체적인 클래스에 의존하지 않고 만들 수 있게 해주는 것이 목적.
04. 빌더 (Builder) 패턴
- 동일한 프로세스를 거쳐 다양한 구성의 인스턴스를 만드는 방법.
- (복잡한) 객체를 만드는 프로세스를 독립적으로 분리할 수 있다.
구현 방법
// Builder
public interface ToyBuilder {
ToyBuilder name(String name);
ToyBuilder size(int size);
Toy build();
}
// ConcreteBuilder
public class DefaultToyBuilder implements ToyBuilder {
private String name;
private int size;
@Override
public ToyBuilder name(String name) {
this.name = name;
return this;
}
@Override
public ToyBuilder size(int size) {
this.size = size;
return this;
}
@Override
public Toy build() {
return new Toy(name, size);
}
}
// Product
public class Toy {
private String name;
private int size;
public Toy(String name, String size) {
this.name = name;
this.size = size;
}
// getter, setter...
}// Director
public class ToyDirector {
private ToyBuilder toyBuilder;
public ToyDirector(ToyBuilder toyBuilder) {
this.toyBuilder = toyBuilder;
}
public Toy sampleToy() {
return toyBuilder.name("sample")
.size(5)
.build();
}
}public static void main(String[] args) {
ToyDirector director = new ToyDirector(new DefaultToyBuilder());
Toy sampleToy = director.sampleToy();
System.out.prinln(sampleToy);
}장단점
장점
- 필요한 데이터만 설정할 수 있다.
- 만들기 복잡한 객체를 순차적으로 만들 수 있다.
- 복잡한 객체를 만드는 구체적인 과정을 숨길 수 있다.
- 동일한 프로세스를 통해 각기 다르게 구성된 객체를 만들 수도 있다. 불완전한 객체를 사용하지 못하도록 방지할 수 있다.
단점
- 원하는 객체를 만들려면 빌더부터 만들어야 한다.
- 구조가 복잡해 진다. (트레이드 오프)
사용하는곳
- Java 8 Stream.Builder API
- StringBuilder
- Lombok @Builder
- Spring UriComponentsBuilder
- ...
05. 프로토타입 (Prototype) 패턴
- 기존 인스턴스를 복제하여 새로운 인스턴스를 만드는 방법.
- 복제 기능을 갖추고 있는 기존 인스턴스를 프로토타입으로 사용해 새 인스턴스를 만들 수 있다.
- 이 패턴은 복사를 위하여 Java 에서는 Object 의
clonemethod 를 활용한다.
구현 방법
public class Employees implements Cloneable {
private final List<String> values;
public Employees() {
this(new ArrayList<>());
}
public Employees(List<String> values) {
this.values = values;
}
public List<String> getValues() {
return values;
}
public void loadData() {
values.add("AA");
values.add("BB");
values.add("CC");
values.add("DD");
}
// shallow copy 일 경우
@Override
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
// deep copy 일 경우
@Override
public Object clone() throws CloneNotSupportedException {
List<String> list = new ArrayList<>(values);
return new Employees(list);
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
Employees that = (Employees) o;
return Objects.equals(values, that.values);
}
@Override
public int hashCode() {
return Objects.hash(values);
}
}public static void main(String[] args) throws CloneNotSupportedException {
Employees employees = new Employees();
employees.loadData();
Employees clone = (Employees) employees.clone();
assert employees != clone;
assert employees.equals(clone);
assert employees.getClass() == clone.getClass();
// shallow copy, depp copy 동일
assert employees.getValues().equals(clone.getValues());
// shallow copy 일 경우
assert employees.getValues() == clone.getValues();
// deep copy 일 경우
assert employees.getValues() != clone.getValues();
}Shallow Copy vs Deep Copy
Shallow Copy
- 객체를 복사할 때, 해당 객체만 복사하여 새 객체를 생성한다.
- 복사된 객체의 인스턴스 변수는 원본 객체의 인스턴스 변수와 참조가 동일하다.
Deep Copy
- 객체를 복사 할 때, 해당 객체와 인스턴스 변수까지 복사하는 방식.
- 전부를 복사하여 새 주소에 담기 때문에 참조를 공유하지 않는다.
장단점
장점
- 복잡한 객체를 만드는 과정을 숨길 수 있다.
- 기존 객체를 복제하는 과정이 새 인스턴스를 만드는 것보다 비용(시간 또는 메모리)적인 면에서 효율적일 수도 있다.
- 추상적인 타입을 리턴할 수 있다.
단점
- 복제한 객체를 만드는 과정 자체가 복잡할 수 있다. (특히, 순환 참조가 있는 경우)
사용하는곳
- Java Object 클래스의 clone 메서드, Cloneable Interface
- ModelMapper
Backend Developer