1220 - 1226

# 1220 - 1226

# 1221 - 전략패턴과 커맨드패턴

인터페이스를 구현하여 사용하는 두 가지 패턴인 전략 패턴과 커맨드 패턴의 차이

# 전략패턴

전략 패턴은 프로그램이 진행되면서 캡슐화된 로직을 선택할 수 있게 하는 디자인 패턴이다. 로직 실행은 인터페이스에 의존을 시키고 인터페이스를 구현한 로직들을 전달해줌으로써 분기처리 없이 유연서을 갖출 수가 있다.

예제 코드

public class PeopleWithMovement {

    private Transportation transportation;

    public PeopleWithMovement(Transportation transportation) {
        this.transportation = transportation;
    }

    public void move(String start, String end) {
        transportation.move(start, end);
    }

    public void changeTransporation(Transportation transportation) {
        this.transportation = transportation;
    }
}

전략을 행항 주체인 Transporation은 인터페이스로 분리되어 캡슐화 되어 있다.

public interface Transportation {

    void move(String start, String end);
}

// 
public class Bicycle implements Transportation {

    @Override
    public void move(String start, String end){
        System.out.println("출발점 : " + start + "에서 목적지 : " + end + "까지 `자전거`로 이동합니다.");
    }
}

// 
public class Bus implements Transportation {

    @Override
    public void move(String start, String end){
        System.out.println("출발점 : " + start + "에서 목적지 : " + end + "까지 `버스`로 이동합니다.");
    }
}

Transporation을 구현하여 Bus와 Bicycle 코드 작성

public class Main {

    public static void main(String[] args) {
        Bicycle bicycle = new Bicycle();
        Bus bus = new Bus();

        PeopleWithMovement whybeFirst = new PeopleWithMovement(bicycle);
        whybeFirst.move("시작점", "끝점");

        PeopleWithMovement whybeSecond = new PeopleWithMovement(bus);
        whybeSecond.move("시작점", "끝점");

        PeopleWithMovement whybeChangeMovement = new PeopleWithMovement(bicycle);
        whybeChangeMovement.move("시작점", "중간지점");
        whybeChangeMovement.changeTransporation(bus);
        whybeChangeMovement.move("중간지점", "끝점");
    }
}

실행 결과

출발점 : 시작점에서 목적지 : 끝점까지 `자전거`로 이동합니다.
출발점 : 시작점에서 목적지 : 끝점까지 `버스`로 이동합니다.
출발점 : 시작점에서 목적지 : 중간지점까지 `자전거`로 이동합니다.
출발점 : 중간지점에서 목적지 : 끝점까지 `버스`로 이동합니다.

# 커맨드 패턴

커맨드 패턴은 요청을 홀로 처리할 수 있도록 요청을 수행하는 여러 인자를 함께 패키징하여 나중에 처리할 수 있도록 만들어주는 행동 중심 디자인 패턴이다. 커맨드를 실행시키는 객체는 커맨드 내부의 요소에 대해서 숨김으로써 코드의 유연성을 가질 수 있다.

예제 코드

public class PeopleWithLottery {

    private List<LotteryCommand> lotteryCommands;

    public PeopleWithLottery(List<LotteryCommand> lotteryCommands) {
        this.lotteryCommands = lotteryCommands;
    }

    public void addLotteryCommand(LotteryCommand lotteryCommand) {
        lotteryCommands.add(lotteryCommand);
    }

    public void scratchAllLottery() {
        for (int i = 0; i < lotteryCommands.size(); i++) {
            LotteryCommand lotteryCommand = lotteryCommands.get(i);
            lotteryCommand.scratch();
        }
        //초기화
        lotteryCommands = new LinkedList<>();
    }
}

public interface LotteryCommand {
    void scratch();
}

public class InstantScratch implements LotteryCommand {
    
    private InstantLottery instantLottery;
    private Account account;

    public InstantScratch(InstantLottery instantLottery, Account account) {
        this.instantLottery = instantLottery;
        this.account = Account;
    }

    @Override
    public void scratch() {
      //instantLottery의 당첨을 확인하고 account에 돈을 집어 넣는 로직
    }
}

public class InstantLottery {
    
    private boolean win;

    public InstantLottery(boolean win) {
        this.win = win;
    }

    public boolean isWin() {
        return win;
    }
}

public class Account {

    private int balance;

    public void putMoney(int money) {
        balance += money;
    }
}

public class Main {
    public static void main(String[] args) {
        PeopleWithLottery whybe = new PeopleWithLottery(new LinkedList<>());
        Account 와이비통장 = new Account();
        
        //즉석복권 구입
        for (int i = 0; i < 10; i++) {
            //즉석복권 생성 로직 
            InstantLottery instantLottery = new InstantLottery(당첨여부);
            //즉석복권긁기행위 객체 생성 및 커맨드 목록에 추가
            InstantScratch 즉석복권긁기커맨드 = new InstantScratch(즉석복권, 와이비통장);
            whybe.addLotteryCommand(즉석복권긁기커맨드);
        }
        
        whybe.scratchAllLotery();
    }
}

당첨을 확인하고 통장에 돈을 추가하는 것을 캡슐화하고, 긁는 행위를 호출하는 객체(People), 명령을 담장하는 객체(LotteryCommand) 그리고 명령 수행으로 인하여 영향을 받는 객체(MyAccount)가 모두 다르게 구성.

public class NumberScratch implements LotteryCommand {

    private Set<Integer> winners;
    private NumberLottery numberLottery;
    private Account account;

    public NumberScratch(Set<Integer> winners, NumberLottery numberLottery, Account account) {
        this.winners = winners;
        this.numberLottery = numberLottery;
        this.account = account;
    }

    @Override
    public void scratch() {
        // winners와 numberLottery를 비교하여 당첨금을 계산하고 
        // account에 해당 금액을 입금하는 로직
    }   
}

public class NumberLottery {
    
    private Set<Integer> numbers;

    public NumberLottery(Set<Integer> numbers) {
        this.numbers = numbers;
    }

    public int rank(Set<Integer> winners) {
        // 당첨 번호와 비교하여 자신의 등수를 계산하는 로직
    }
}

public class Main {
    public static void main(String[] args) {
        PeopleWithLottery whybe = new PeopleWithLottery(new LinkedList<>());
        Account 영이통장 = new Account();
        
        //즉석복권 구입
        for (int i = 0; i < 10; i++) {
            //번호식 복권 생성 로직 
            NumberLottery 번호식복권 = new NumberLottery(선택한 번호);
            //번호식복권긁기행위 객체 생성 및 커맨드 목록에 추가
            NumberScratch 번호식복권긁기커맨드 = new NumberScratch(이번주 당첨번호, 번호식복권, 영이통장);
            whybe.addLotteryCommand(번호식복권긁기커맨드);
        }

        whybe.scratchAllLottery();
    }
}

행위를 캡슐화하여 복권을 긁는 행위를 호출하는 객체인 PeopleWithLottery와 명령 수행으로 인하여 영향을 받는 객체에 큰 변화를 거치지 않도록 만듬

# 전략패턴과 커맨드패턴의 차이

전략 패턴은 어떻게라는 측면에 집중. 커맨드 패턴은 무엇에 초점

# 1224 - Multipart

# Multipart란?

웹 클라이언트가 요청을 보낼 때, http 프로토콜의 바디 부분에 데이터를 여러 부분으로 나눠서 보내는 것. 웹 클라이언트가 서버에게 파이을 업로드 할 때, http 프로토콜의 바디 부분에 파일정보를 담아서 전송을 하는데, 파일을 한번에 여러개 전송을 하면 body 부분에 파일이 여러개의 부분으롤 연결되어 전송된다. 이렇게 여러 부분으로 나뉘어서 전송되는 것을 Multipart data라고 한다.
보통 파일을 전송할 때 사용한다.

# HttpServletRequest는 파일 업로드를 지원하지 않는다.

HttpServletRequest는 웹 클라이언트가 전달하는 Multipart 데이터를 쉽게 처리하는 메소드를 제공하지 않는다. (HttpServletRequest는 http 프로토콜의 body 부분을 읽어들이는 input 스트림안을 지원, 사용자는 이런 input 스트림을 이용해서 Multipart부분을 잘 나누어서 사용해야한다. 보통은 직접 구현하지 않고 라이브러리를 사용)
서블릿에서 파일 업로드를 처리하려면 별도의 라이브러리를 사용해야 한다. 대표적인 라이브러리가 아파치 재단의 commons-filedupload이다.

# Spring MVC에서의 파일 업로드

Spring MVC에서 파일 업로드 하려면 몇가지 라이브러리와 설정을 추가

commons-fileupload, commons-io 라이브러리 추가
MultipartResolver Bean 추가
DispatcherServlet은 준비과정에서 "multipart/form-data"가 요청으로 올 경우 MultipartResolver를 사용한다. (MultipartFile 매개변수를 사용하기 위해서는 MultipartResolver Bean이 등록되어있어야 한다.)

@Bean
public MultipartResolver multipartResolver(){
    org.springframework.web.multipart.commons.CommonsMultipartResolver multipartResolver = new 
    org.springframework.web.multipart.commons.CommonsMultipartResolver();
    
    multipartResolver.setMaxUplaodSize(10485760); //1024 * 1024 * 10 (최대 10MB)
    return multipartResolver;
}

package org.springframework.boot.autoconfigure.web.servlet;

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass({ Servlet.class, StandardServletMultipartResolver.class, MultipartConfigElement.class })
@ConditionalOnProperty(prefix = "spring.servlet.multipart", name = "enabled", matchIfMissing = true)
@ConditionalOnWebApplication(type = Type.SERVLET)
@EnableConfigurationProperties(MultipartProperties.class)
public class MultipartAutoConfiguration {

	private final MultipartProperties multipartProperties;

	public MultipartAutoConfiguration(MultipartProperties multipartProperties) {
		this.multipartProperties = multipartProperties;
	}

	@Bean
	@ConditionalOnMissingBean({ MultipartConfigElement.class, CommonsMultipartResolver.class })
	public MultipartConfigElement multipartConfigElement() {
		return this.multipartProperties.createMultipartConfig();
	}

	@Bean(name = DispatcherServlet.MULTIPART_RESOLVER_BEAN_NAME)
	@ConditionalOnMissingBean(MultipartResolver.class)
	public StandardServletMultipartResolver multipartResolver() {
		StandardServletMultipartResolver multipartResolver = new StandardServletMultipartResolver();
		multipartResolver.setResolveLazily(this.multipartProperties.isResolveLazily());
		return multipartResolver;
	}

}

MultipartResolver는 SpringMVC에서 기본적으로 등록해주지 않지만, SpringBoot에서는 위와 같이 MultipartAutoConfiguration클래스에서 MultipartResolver Bean이 등록되어있지 않는 경우 자동으로 Bean을 등록해준다. 따라서 SpringBoot에서는 별도의 설정없이 MultipartFile 매개변수를 사용할 수 있다.

# 1225 - @AuthenticationPrincipal

스프링 시큐리티는 SecurityContext에 인증된 Authentication 객체를 넣어두고 현재 스레드 내에서 공유되도록 관리하고 있다. 보통은 인증 이후 @AuthenticationPrincipal 어노테이션을 통해 UserDetails 인터페이스를 구현한 유저 객체를 주입할 때 사용하는 편이다.

# 동작 원리

현재 스레드가 세션을 물고 있다면 이미 SecurityContextHolder의 getContext() 메소드를 통해 SecurityContext 객체를 얻고 그 안의 getAuthentication() 메소드를 통해 Authentication (인증객체)를 얻을 수 있다.

@PostMapping(value = "/logout", 
             consumes = MediaTypes.HAL_JSON_VALUE, 
             produces = MediaTypes.HAL_JSON_VALUE)
public Object logout(@AuthenticationPrincipal SecurityUser securityUser, 
                     @RequestHeader("Authorization") String authorization) throws Exception {
    // 컨트롤러 로직
}

Spring Security를 사용하는 경우, AuthenticationPrincipalArgumentResolver 클래스를 활용하여 resolveArgument 메소드를 구현하고 SecurityContext에 저장된 인증객체를 기반으로 Authentication 객체를 꺼내오게 된다.

public final class AuthenticationPrincipalArgumentResolver implements HandlerMethodArgumentResolver {

	private ExpressionParser parser = new SpelExpressionParser();

	private BeanResolver beanResolver;

	@Override
	public boolean supportsParameter(MethodParameter parameter) {
		return findMethodAnnotation(AuthenticationPrincipal.class, parameter) != null;
	}

	@Override
	public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
			NativeWebRequest webRequest, WebDataBinderFactory binderFactory) {
            
        // Security Context에서 꺼내욘 객체를 기반으로 한다.
		Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
		if (authentication == null) {
			return null;
		}

        // 인증객체에서 Principal을 꺼낸다.
		Object principal = authentication.getPrincipal();

        // 해당 어노테이션이 붙은 파라미터가 존재하는지 찾는다.
		AuthenticationPrincipal annotation = findMethodAnnotation(AuthenticationPrincipal.class, parameter);
		String expressionToParse = annotation.expression();
		if (StringUtils.hasLength(expressionToParse)) {
			StandardEvaluationContext context = new StandardEvaluationContext();
			context.setRootObject(principal);
			context.setVariable("this", principal);
			context.setBeanResolver(this.beanResolver);
			Expression expression = this.parser.parseExpression(expressionToParse);
			principal = expression.getValue(context);
		}
		if (principal != null && !parameter.getParameterType().isAssignableFrom(principal.getClass())) {
			if (annotation.errorOnInvalidType()) {
				throw new ClassCastException(principal + " is not assignable to " + parameter.getParameterType());
			}
			return null;
		}

        // principal 리턴
		return principal;
	}

	public void setBeanResolver(BeanResolver beanResolver) {
		this.beanResolver = beanResolver;
	}

	private <T extends Annotation> T findMethodAnnotation(Class<T> annotationClass, MethodParameter parameter) {
		T annotation = parameter.getParameterAnnotation(annotationClass);
		if (annotation != null) {
			return annotation;
		}
		Annotation[] annotationsToSearch = parameter.getParameterAnnotations();
		for (Annotation toSearch : annotationsToSearch) {
			annotation = AnnotationUtils.findAnnotation(toSearch.annotationType(), annotationClass);
			if (annotation != null) {
				return annotation;
			}
		}
		return null;
	}

}

컨트롤러의 파라미터마다 해당 resolveArgument 메소드가 실행된다.

1213 - 1219