0830 - 0905

0831 - Spring : consumes와 produces의 차이

Controller에서 Mapping을 할 때 주고 받는 데이터를 강제함으로써 오류상황을 줄인다. 이때 사용하는 것 중 하나가 Media Types이다.

consumes

consumes는 들어오는 데이터 타입을 정의할 때 이용한다.

@PostMapping(path = "/pets", consumes = MediaType.APPLICATION_JSON_VALUE) 
public void addPet(@RequestBody Pet pet) {
    // ...
}

• 이렇게 처리를 하게되면 해당 uri를 호출하는 쪽에서는 헤더에 보내는 데이터가 json이라는 것을 명시해야 한다.

Content-Type:application/java

produces

produces는 반환하는 데이터 타입을 정의한다.

@GetMapping(path = "/pets/{petId}", produces = MediaType.APPLICATION_JSON_VALUE) 
@ResponseBody
public Pet getPet(@PathVariable String petId) {
    // ...
}

• 이럴 경우 반환 타입이 json으로 강제된다.

Accept:application/json

요약

• consumes는 클라이언트가 서버에게 보내는 데이터 타입을 명시한다.
• produces는 서버가 클라이언트에게 반환하는 데이터 타입을 명시한다.

0901 - 배열 정렬

Arrays.sort에 Comparator사용 compare 메소드 구현

• Comparator는 기본적으로 객체를 비교할 수 있또록 해주는 인터페이스이다.
• 자바 기본자료형이 아닌 사용자 클래스의 비교나 특정 규칙에 의해 비교를 하고 싶은 경우에 구현한다.

Arrays.sort의 형태

public static <T> void sort(T[] a, Comparator<? super T> c) {
    if (c == null) {
        sort(a);
    } else {
        if (LegacyMergeSort.userRequested)
            legacyMergeSort(a, c);
        else
            TimSort.sort(a, 0, a.length, c, null, 0, 0);
    }
}

• 인자로 Comparator의 타입을 넣고 compare 메소드를 오버라이딩한다.

예제

String[] arr = new String[N];	// 배열에 단어가 이미 초기화 되었다고 가정
 
Arrays.sort(arr, new Comparator<String>() {		
	@Override
	public int compare(String s1, String s2) {
		// 단어 길이가 같을 경우
		if(s1.length() == s2.length()} {
			return s1.compareTo(s2);	// 사전 순 정렬
		}
		// 그 외의 경우
		else {
			return s1.length() - s2.length();
		}
	}
});

• compare 메소르 리턴 타입이 int인 이유는 양의 정수, 0, 음의 정수에 따라 위치를 변경한다.
  • 양수 = 위치 변경
  • 0 and 음수 = 그대로

0902 - 자바 정규 표현식 (Pattern, Matcher)

정규표현식

정규표현식(Regular Expression)이란 컴퓨터 과학의 정규언어로부터 유래한 것으로 특정한 규칙을 가진 문자열의 집합을 표현하기 위해 쓰이는 형식언어이다. 정해진 형식에 맞는지 검증해야할때 사용 할 수 있다.

자바에서의 정규표현식

• 정규 표현식을 작성하는 방법은 자바 API java.util.regex 패키지를 사용해야 한다.

Pattern 클래스

import java.util.regex.Pattern;

public class RegexExample {
	public static void main(String[] args)  {
    
            String pattern = "^[0-9]*$"; //숫자만
            String val = "123456789"; //대상문자열
        
            boolean regex = Pattern.matches(pattern, val);
            System.out.println(regex);
    }
}

• 문자열 패턴 검증은, Pattern 클래스의 matches() 메소드를 활용.

Pattern 클래스의 주요 메서드

• compile(String regex) : 주어진 정규포현식으로부터 패턴을 생성
• matcher(CharSequence input) : 대상 문자열이 패턴과 일치할 경우 true를 반환.
• asPredicate() : 문자열을 일치시키는데 사용할 수 있는 술어를 작성.
• pattern() : 컴파일된 정규표현식을 String 형태로 반환.
• split(CharSequence input) : 문자열을 주어진 인자값 CharSequence 패턴데 따라 분리.

Matcher 클래스

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexExample {
	public static void main(String[] args)  {
            Pattern pattern = Pattern.compile("^[a-zA-Z]*$"); //영문자만
            String val = "abcdef"; //대상문자열
	
            Matcher matcher = pattern.matcher(val);
            System.out.println(matcher.find());
	}
}

• Matcher 클래스는 대상 문자열의 패턴을 해석하고 주어진 패턴과 일치하는지 판별할 때 주로 사용.

Matcher 클래스 주요 메서드

• matches() : 대상 문자열과 패턴이 일치할 경우 true 반환.
• find() : 대상 문자열과 패턴이 일치하는 경우 true를 반환하고, 그 위치로 이동.
• find(int start) : start위치 이후부터 매칭검색을 수행.
• start() : 매칭되는 문자열 시작위치 반환.
• start(int group) : 지정된 그룹이 매칭되는 시작위치 반환.
• end() : 매칭되는 문자열 끝 다음 문자위치 반환.
• end(int group) : 지정되 그룹이 매칭되는 끝 다음 문자위치 반환.
• group() : 매칭된 부분을 반환.
• group(int group) : 매칭된 부분중 group번 그룹핑 매칭부분 반환.
• groupCount() : 패턴내 그룹핑한(괄호지정) 전체 갯수를 반환.

0903 - Bean Validation 데이터 유효성 검사 프레임워크 사용하기.

설치

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-validation</artifactId>
</dependency>

제약 설정과 검사

public class CreateContact {
    @Length(max = 64) // 최대 길이 64
    @NotBlank // 빈문자열은 안됨
    private String uid;
    @NotNull // null 안됨
    private ContactType contactType;
    @Length(max = 1_600) // 최대 길이 1,600
    private String contact;
}

• 도메인 검증

 @BeforeClass
    public static void beforeClass() {
        Locale.setDefault(Locale.US); // locale 설정에 따라 에러 메시지가 달라진다.
    }

    @Test
    public void test_validate() {
        // Given
        final Validator validator = Validation.buildDefaultValidatorFactory().getValidator();

        final CreateContact createContact = CreateContact
            .builder()
            .uid(null) // @NotBlank가 정의되어 있기때문에 null이 오면 안된다.
            .contact("000")
            .contactType(ContactType.PHONE_NUMBER)
            .build();

        // When
        final Collection<ConstraintViolation<CreateContact>> constraintViolations = validator.validate(createContact);

        // Then
        assertEquals(1, constraintViolations.size());  // ConstraintViolation에 실패에 대한 정보가 담긴다.
        assertEquals("must not be blank", constraintViolations.iterator().next().getMessage());
    }

• 유효성 검사 검증 코드

Spring에서 사용하기

• Service나 Bean에서 사용하기 위해서는 @Validated와 @Valid를 추가

@Validated // 여기에 추가
@Service
public class ContactService {
    public void createContact(@Valid CreateContact createContact) { // '@Valid'가 설정된 메서드가 호출될 때 유효성 검사를 진행한다.
        // Do Something
    }
}

• Controller에서는 @Validated가 필요 없다. 검사를 진행할 곳에 '@Valid'를 추가하면 된다.

    @PostMapping("/contacts")
    public Response createContact(@Valid CreateContact createContact) { // 메서드 호출 시 유효성 검사 진행
        return Response
            .builder()
            .header(Header
                .builder()
                .isSuccessful(true)
                .resultCode(0)
                .resultMessage("success")
                .build())
            .build();
    }

컨테이너에서의 사용(컬렉션, 맵, ...)

public class DeleteContacts {
    @Min(1)
    private Collection<@Length(max = 64) @NotBlank String> uids;
}

사용자 정의 제약(Custom Constraint)

• 임의의 제약(Constraint)과 검증자(Validator)를 구현

@Target({METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE})
@Retention(RUNTIME)
@Constraint(validatedBy = NoEmojiValidator.class)
@Documented
public @interface NoEmoji{
    String message() default "Emoji is not allowed";

    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};

    @Target({METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER})
    @Retention(RUNTIME)
    @Documented
    @interface List{
        NoEmoji[] value();
    }
    public class NoEmojiValidator implements ConstraintValidator<NoEmoji, String> {
        @Override
        public boolean isValid(String value, ConstraintValidatorContext context) {
        if (StringUtils.isEmpty(value) == true) {
            return true;
        }

        return EmojiParser.parseToAliases(value).equals(value);
        }
    }
}

public class CreateContact {
    @NoEmoji
    @Length(max = 64)
    @NotBlank
    private String uid;
    @NotNull
    private ContactType contactType;
    @Length(max = 1_600)
    private String contact;
}

제약 그룹(Grouping)

public class Message {
    @Length(max = 128)
    @NotEmpty
    private String title;
    @Length(max = 1024)
    @NotEmpty
    private String body;
    @Length(max = 32, groups = Ad.class)
    @NotEmpty(groups = Ad.class)  // 그룹을 지정할 수 있다. (기본 값은 javax.validation.groups.Default)
    private String contact;
    @Length(max = 64, groups = Ad.class)
    @NotEmpty(groups = Ad.class)
    private String removeGuide;
}

public interface Ad {
}

• 'Ad.class'는 단순히 그룹을 지정하기 위한 마커 인터페이스(Marker Interface)다.

@Validated
@Service
public class MessageService {
    @Validated(Ad.class) // 메서드 호출 시 Ad 그룹이 지정된 제약만 검사한다.
    public void sendAdMessage(@Valid Message message) {
        // Do Something
    }

    public void sendNormalMessage(@Valid Message message) {
        // Do Something
    }

    /**
     * 주의: 이렇게 호출하면 Spring AOP Proxy 구조상 @Valid를 설정한 메서드가 호출되어도 유효성 검사가 동작하지 않는다. 
     * Spring의 AOP Proxy 구조에 대한 설명은 다음 링크를 참고하자.
     * - https://docs.spring.io/spring/docs/5.2.3.RELEASE/spring-framework-reference/core.html#aop-understanding-aop-proxies
     */
    public void sendMessage(Message message, boolean isAd) {
        if (isAd) {
            sendAdMessage(message);
        } else {
            sendNormalMessage(message);
        }
    }

클래스 단위 제약(Class Level Constraint)과 조건부 검사(Conditional Validation)

• 도메일 보델의 속성긔 값에 따라 데이터 유혀성 검사를 다르게 해야할 경우에 사용

@AdMessageConstraint // 이 커스텀 제약을 구현할 것이다.
public class Message {
    @Length(max = 128)
    @NotEmpty
    private String title;
    @Length(max = 1024)
    @NotEmpty
    private String body;
    @Length(max = 32, groups = Ad.class)
    @NotEmpty(groups = Ad.class)
    private String contact;
    @Length(max = 64, groups = Ad.class)
    @NotEmpty(groups = Ad.class)
    private String removeGuide;
    private boolean isAd; // 광고 여부를 설정할 수 있는 속성
}

@Target({TYPE})
@Retention(RUNTIME)
@Constraint(validatedBy = AdMessageConstraintValidator.class)
@Documented
public @interface AdMessageConstraint {
    String message() default "";

    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};

    public class AdMessageConstraintValidator implements ConstraintValidator<AdMessageConstraint, Message> {
        private Validator validator;

        public AdMessageConstraintValidator(Validator validator) {
            this.validator = validator;
        }

        @Override
        public boolean isValid(Message value, ConstraintValidatorContext context) {
            if (value.isAd()) {
                final Set<ConstraintViolation<Object>> constraintViolations = validator.validate(value, Ad.class);
                if (CollectionUtils.isNotEmpty(constraintViolations)) {
                    context.disableDefaultConstraintViolation();
                    constraintViolations
                            .stream()
                            .forEach(constraintViolation -> {
                                context.buildConstraintViolationWithTemplate(constraintViolation.getMessageTemplate())
                                        .addPropertyNode(constraintViolation.getPropertyPath().toString())
                                        .addConstraintViolation();
                            });
                    return false;
                }
            }

            return true;
        }
    }
}

@Validated
@Service
public class MessageService {
    /**
     * message.isAd가 true이면 contcat, removeGuide 속성까지 검사한다.
     */
    public void sendMessage(@Valid Message message) {
         // Do Something
    }

오류 처리(Error Handling)

• 데이터 유효성 검사 시 실패가 발생하면 ConstraintViolationException 발생. 이를 @ControllerAdvice 구현 컨트롤러에서 @ExceptionHandler 핸들러 구현

@ControllerAdvice
public class GlobalExceptionHandler extends ResponseEntityExceptionHandler {
    @ExceptionHandler(value = ConstraintViolationException.class) // 유효성 검사 실패 시 발생하는 예외를 처리
    @ResponseBody
    protected Response handleException(ConstraintViolationException exception) {
        return Response
            .builder()
            .header(Header
                .builder()
                .isSuccessful(false)
                .resultCode(-400)
                .resultMessage(getResultMessage(exception.getConstraintViolations().iterator())) // 오류 응답을 생성
                .build())
            .build();
    }

    protected String getResultMessage(final Iterator<ConstraintViolation<?>> violationIterator) {
        final StringBuilder resultMessageBuilder = new StringBuilder();
        while (violationIterator.hasNext() == true) {
            final ConstraintViolation<?> constraintViolation = violationIterator.next();
            resultMessageBuilder
                .append("['")
                .append(getPopertyName(constraintViolation.getPropertyPath().toString())) // 유효성 검사가 실패한 속성
                .append("' is '")
                .append(constraintViolation.getInvalidValue()) // 유효하지 않은 값
                .append("'. ")
                .append(constraintViolation.getMessage()) // 유효성 검사 실패 시 메시지
                .append("]");

            if (violationIterator.hasNext() == true) {
                resultMessageBuilder.append(", ");
            }
        }

        return resultMessageBuilder.toString();
    }

    protected String getPopertyName(String propertyPath) {
        return propertyPath.substring(propertyPath.lastIndexOf('.') + 1); // 전체 속성 경로에서 속성 이름만 가져온다.
    }
}

동적 메시지 생성(Message Interpolation)

...
public @interface NoEmoji{
    String message() default "Emoji is not allowed";

    ...

• 매개 변수를 사용할 수 있다.
  1. '{}'또는 '${}'로 둘러싼다.
  2. {,},,$는 문자로 취급.
  3. '{'는 매개변수의 시작, '}'는 매개변수의 끝, \는 확장문자, '$'는 표현식 시작으로 취급.

참고

https://meetup.toast.com/posts/223