1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Calculator {
	public int calculate(boolean firstGuest, List<Item> items) {
		int sum = 0;
		for (Item item : items) {
			if (firstGuest) {
				// ... 첫번째 손님 할인 정책
			} else if (!item.isFresh()) {
				// ... 덜 신선한 음식 할인 정책
			} else {
				sum += item.getPrice();
			}
		}
		return sum;
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Calculator {
	private DiscountStrategy discountStrategy;
	
	// 의존성 주입
	public Caclulator(DiscountStrategy discountStrategy) {
		this.discountStrategy = discountStrategy;
	}
	
	public int caclulate(List<Item> items) {
		int sum = 0;
		for (Item item : items) {
			sum += discountStrategy.getDiscountPrice(item);
		}
		return sum;
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class Client {
	private DiscountStrategy strategy;
	
	...
	
	// 첫 손님 할인 버튼
	public void onFirstGurestButtonClick() {
		strategy = new FirstGuestDiscountStrategy();
	}
	
	//계산 버튼
	public void onCalculatorButtonClick() {
		Calculaotor cal = new Calculaotr(strategy);
		int price = cal.calculate(items);
		...
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public abstract Authenticator {

	//템플릿 메서드
	public Auth authenticate(String id, String pw) {
		//사용자 정보로 인증 확인
		if (! doAuthenticate(id, pw)) {
			// 인증 실패 처리
			throw createException();
		}
		//인증 성공 처리
		return createAuth(id);
	}
	
	protected abstract boolean doAuthentication(String id, String pw);
	
	private RuntimeException createException() {
		throw new AuthException();
	}
	
	protected abstract Auth createAuth(String id);
}

1
2
3
4
5
6
7
8
9
10
11
12
public class LdapAuthenticator extends Authenticator {
	@Override
	protected boolean doAuthenticate(String id, String pw) {
		return ldapClient.authenticate(id, pw);
	}
	
	@Override
	protected boolean createAuth(String id) {
		LdapContext ctx = ldapClient.find(id);
		return new Auth(id, ctx.getAttribute("name"));
	}
} 

1
2
3
4
5
6
7
8
9
10
public class SuperCar extends ZetEngine {
	@Overried
	public void turnOn() {
		//하위 클래스에서의 흐름 제어
		if (notReady)
			beep();
		else
			super.turnOn();	
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public <T> T execute(TransactionCallback <T> action) throws TransactionException {
	....
	
	TransactionStatus status = this.transactionManager.getTransaction(this);
	T result;
	
	//시작, 커밋, 롤백의 실행 흐름을 구현하고있다.
	try {
		// TransactionCallback 전략의 구현체인 action을 파라미터로 전달 받아 사용한다.
		result = action.doInTransaction(status);
	}
	catch (RuntimeException ex) {
		rollbackOnException(status, ex);
		throw ex;
	}
	
	...
	
	this.transactionMAnager.commit(status);
	return result;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class MyService {
    private final TransactionTemplate transactionTemplate;

    public MyService(PlatformTransactionManager transactionManager) {
        this.transactionTemplate = new TransactionTemplate(transactionManager);
    }

    public void executeBusinessLogic() {
        transactionTemplate.execute(status -> {
            // TransactionCallback 인터페이스의 구현 작성
            return null;
        });
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public class VendingMAchine {
	public static enum State {NOCOIN, SELECTABLE}
	
	private State state = State.NOCOIN;
	
	public void insertCoin(int coin) {
		switch(state) {
			case NOCOIN:
				increaseCoin(coin);
				state = State.SELECTABLE;
				break;
			case SELECTABLE:
				increaseCoin(coin);
		}
	}
	
	public void select(int productId) {
		switch(state) {
			case NOCOIN:
				break;
			case SELECTABLE:
				provideProduct(productId);
				dereaseCoin();
				if (hasNoCoin) state = State.NOCOIN;
		}
	}
	
	....
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class VendingMachine {
	private State state;
	
	public VendingMachine() {
		state = new NoCoinState();
	}
	
	public void insertCoin(int coin) {
		state.increaseCoin(coin, this) //위임
	}
	
	public void select (int productId) {
		state.select(productId, this); //위임
	}
	
	public void changeState(State newState) {
		this.state = newState;
	}
	
	....
}

1
2
3
4
5
6
7
8
9
10
11
12
13
public class NoCoinState implements State {

	@Override
	public void increaseCoin(int coin, VendingMachine vm) {
		vm.increaseCoin(coin);
		vm.changeState(new SelectableState());
	}
	
	@Override
	public void select(int productId, VendingMachine vm) {
		SoundUtil.beep();
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class NoCoinState implements State {

	@Override
	public void increaseCoin(int coin, VendingMachine vm) {
		vm.increaseCoin(coin);
		//콘텍스트의 상태 변경
		vm.changeState(new SelectableState());
	}
	
	@Override
	public void select(int productId, VendingMachine vm) {
		SoundUtil.beep();
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
public abstract class Decorator implements FileOut {
	private FileOut delegate;
	
	public Decorator(FileOut delegate) {
		this.delegate = delegate;
	}
	
	protected void doDelegate(byte[] data) {
	 //delegate에 쓰기 위임
		delegate.wrtie(data);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
public abstract class EncrptionOut implements Decorator {
	
	public EncrptionOut(FileOut delegate) {
		super(delegate);
	}
	
	protected void write(byte[] data) {
	 byte [] encryptedData = encrypt(data);
	 super.doDelegate(encryptedData);
	}
	
	...
}

1
2
3
FileOut delegate = new FileOutImpl();
FileOut fileOut = new EncrptionOut(delegate);
fileOut.write(data);

1
2
3
4
FileOut delegate = new FileOutImpl();
FileOut zippedFile = new ZipOut(delegate);
FileOut encryptZippedFile = new EncrptionOut(zippedFile);
fileOut.write(encryptZippedFile);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class ProxyImage implements Image {
	private String path;
	private RealImage image;
	
	public ProxyImage(String path) {
		this.path = path;
	}
	public void draw() {
		if (image == null) {
			// 이미지가 로딩되지 않은 경우 실제 이미지 객체를 생성한다.
			image = new RealImage(path); 
		}
		// 이미지가 로딩되어 있는 경우 RealImage 객체에 위임한다.
		image.draw(); 
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class ListUI {
	private List<Image> images;
	public ListUI(List<Image> images) {
		this.images = images;
	}
	
	public void onScroll(int start, int end) {
	// 스크롤이 되는 시점에 Image 객체의 draw 메서드를 실행시킨다.
		for(int i = start; i <= end; i++) {
			Image image = images.get(i);
			image.draw();
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class SearchServiceTolrAdapeter implements SearchService {
	private TolrClient tolrClient = new TolrClient();
	
	public SearchResult(String keyword) {
		//keyword를 tolrClient가 요구하는 형태로 변환
		TolrQuery tolrQuery = new TolrQuery(keyword);
	
		//TolrClient 기능 실행
		QueryResponse response = tolrClient.query(tolrQuery);
		
		//TolrClient의 결과를 SearchResult로 변환
		SearchResult result = convertToResult(response);
		return result;
	}
	
	....
}