Spring Boot version 2.1.x에서 2.2.x (spring frame 5.2 이상)으로 버전업 진행 시 Spring Cloud AWS SnsAutoConfiguration 에서 TypeNotPresentExceptionProxy 가 발생하며 실행안되는 문제

web/Spring|2020. 8. 21. 15:10

문제 발생


평소 문제가 많았던 webflux 부분 수정을 위해 spring boot 2.1.3에서 2.2.7버전으로 업그레이드를 진행하기 위해 gradle에서 spring boot version을 2.2.7로 변경하고 애플리케이션을 실행 시켰다. 

 

그런데 평소에는 자주본적이 없던 TypeNotPresentExceptionProxy 에러가 발생했다. 

org.springframework.beans.factory.BeanDefinitionStoreException: Failed to process import candidates for configuration class [com.baemin.bmart.search.BmartSearchAdminApplication]; nested exception is java.lang.ArrayStoreException: sun.reflect.annotation.TypeNotPresentExceptionProxy
	at org.springframework.context.annotation.ConfigurationClassParser.processImports(ConfigurationClassParser.java:609)
	at org.springframework.context.annotation.ConfigurationClassParser.access$800(ConfigurationClassParser.java:110)
	at org.springframework.context.annotation.ConfigurationClassParser$DeferredImportSelectorGroupingHandler.lambda$processGroupImports$1(ConfigurationClassParser.java:811)
	at java.util.ArrayList.forEach(ArrayList.java:1257)

에러가 발생한 호출 스택 정보를 보니 ConfigurationClassParser에 processImports에서 발생한걸로 보아 @Configuration 어노테이션이 적용된 클래스에서 빈정보를 import하다가 에러가 발생한 것 같았다.

 

그래서 어떤 에러로 인해 발생한 것인지 확인해보기 위해서 TypeNotPresentExceptionProxy 클래스에 디버깅을 찍고 문제가 발생한 로그를 확인해봤다.

 

java.lang.NoClassDefFoundError org/springframework/web/servlet/config/annotation/WebMvcConfigurer 가 발행했다.

 

WebMvcConfigurer NoClassDefFoundError가 발생할 이유가 없는데 발생하여 난감해하고 있었는데 확인해보니 내부적으로 사용중이던 compile 'org.springframework.cloud:spring-cloud-aws-messaging' 라이브러리에서 SnsWebConfiguration이 있는데 이게 2.1.0버전에는 아래와 같이 구현되어 있다.

@Configuration
@ConditionalOnClass("org.springframework.web.servlet.config.annotation.WebMvcConfigurer")
public class SnsWebConfiguration implements WebMvcConfigurer {

    @Autowired
    private AmazonSNS amazonSns;

    @Override
    public void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
        argumentResolvers.add(getNotificationHandlerMethodArgumentResolver(this.amazonSns));
    }
}

여기서 Class가 class path에 잘 있는지 확인하는 @ConditionalOnClass 어노테이션의 value에 WebMvcConfigurer 클래스의 존재를 체크하도록 설정되어 있다.

 

@ConditionalOnClass의 경우에는 해당 클래스가 잘 있으면 Bean으로 등록하라는 하나의 조건인데 만약 WebMvcConfigurer이 없으면 해당 Configuraion을 안쓰면 되는데 왜 죽은거서 인가 하고 의아했다.

 

여기서 같은 실에 개발자인 용근님이 올리신 issue를 보고 알게 되었다. 

https://github.com/spring-cloud/spring-cloud-aws/issues/549

https://github.com/spring-cloud/spring-cloud-aws/issues/503

 

ArrayStoreException in SnsWebConfiguration. · Issue #549 · spring-cloud/spring-cloud-aws

Hello, Because implement and ConditionalOnClass are specified in SnsWebConfiguration at the same time, an exception occurs during the class load. When WebMvcConfigurer does not exist, Caused by: ja...

github.com

SnsWebConfiguration에서 WebMvcConfigurer를 implements하고 있는데 해당 classpath를 찾을 수 없어 발생한 오류입니다.

 

그런데 왜 단순히 spring boot version만 올렸고 spring cloud aws 버전은 2.1.0버전 그대로 사용하고 있는데, 이게 2.1.3버전에서는 발생하지 않고 2.2.7버전에서만 발생한건지 궁금해서 원인을 찾아보았다.

 

 

 

원인분석


우선 두 개의 버전에서 어떤 차이가 있는지 정확하게 알지 못하기에 spring boot가 뜨기 위해서 호출하는 ConfigurationConfigurationClassParser 부분을 집중적으로 확인해봤다.

 

두 개의 버전을 사용하는 모듈을 동시에 실행시켜 놓고 ConfigurationClassParser클래스에 processImports부분을 살펴봤다. 디버깅 코드를 찍고 오류가 시작되는 부분을 찾고 호출스택을 하나씩 역추적해봤다. 

 

의미있는 부분부터 정리하면 processImports 메소드가 호출되고 내부 코드에서 아래 processConfigurationClass를 호출하고 그 내부에서 doProcessConfigurationClass메소드를 다시 호출한다.

 

이 과정을 통해 configuration class들에 대한 메타데이터 정보를 수집하게 되는데 이때 메타데이터를 수집하기 위해서 사용되는 클래스가 SimpleMetadataReader 이다.

 

아래 두 개의 코드를 보면 차례로 2.1.3 버전의 코드와 2.2.7버전의 SimpleMetadataReader를 확인할 수 있다.

SimpleMetadataReader(Resource resource, @Nullable ClassLoader classLoader) throws IOException {
   InputStream is = new BufferedInputStream(resource.getInputStream());
   ClassReader classReader;
   try {
      classReader = new ClassReader(is);
   }
   catch (IllegalArgumentException ex) {
      throw new NestedIOException("ASM ClassReader failed to parse class file - " +
            "probably due to a new Java class file version that isn't supported yet: " + resource, ex);
   }
   finally {
      is.close();
   }

   AnnotationMetadataReadingVisitor visitor = new AnnotationMetadataReadingVisitor(classLoader);
   classReader.accept(visitor, ClassReader.SKIP_DEBUG);

   this.annotationMetadata = visitor;
   // (since AnnotationMetadataReadingVisitor extends ClassMetadataReadingVisitor)
   this.classMetadata = visitor;
   this.resource = resource;
}
SimpleMetadataReader(Resource resource, @Nullable ClassLoader classLoader) throws IOException {
   SimpleAnnotationMetadataReadingVisitor visitor = new SimpleAnnotationMetadataReadingVisitor(classLoader);
   getClassReader(resource).accept(visitor, PARSING_OPTIONS);
   this.resource = resource;
   this.annotationMetadata = visitor.getMetadata();
}

private static ClassReader getClassReader(Resource resource) throws IOException {
	try (InputStream is = resource.getInputStream()) {
		try {
			return new ClassReader(is);
		}
		catch (IllegalArgumentException ex) {
			throw new NestedIOException("ASM ClassReader failed to parse class file - " +
				"probably due to a new Java class file version that isn't supported yet: " + resource, ex);
		}
	}
}

두 개 생성자를 보면 ClassReader를 가지고 오는 부분이 메서드로 2.2.7버전에서 빠진것을 제외해보면 다른 부분이 MetadataReadingVisitor 클래스가 다르다는 것이다.

 

2.1.3버전에서는 AnnotationMetadataReadingVisitor를 사용하고 2.2.7버전에서는 SimpleAnnotationMetadataReadingVisitor를 사용하는데 AnnotationMetadataReadingVisitor은 spring 5.2버전 부터 deprecated되었다.

 * @deprecated As of Spring Framework 5.2, this class has been replaced by
 * {@link SimpleAnnotationMetadataReadingVisitor} for internal use within the
 * framework, but there is no public replacement for
 * {@code AnnotationMetadataReadingVisitor}.
 */

 

그럼 이 MetadataReadingVisitor클래스가 무엇인지 확인해보자. 이 클래스들에 대한 설명은 아래와 같은데 정리해보면 AnnotaionMetadata 인터페이스를 통해 공개되어 있는 클래스 이름과 구현된 클래스에 정의되어 있는 어노테이션 뿐만 아니라 구현된 타입을 찾기 위한 ASM Class visitor 라고 설명이 되어있다.

* ASM class visitor which looks for the class name and implemented types as
* well as for the annotations defined on the class, exposing them through
* the {@link org.springframework.core.type.AnnotationMetadata} interface.

ASM은 자바 바이트코드를 조작하고 분석하는 프레임워크인데 위에 MetadataReadingVisitor들은 결국 Configuration class import parse를 하는 작업에서 메타 데이터를 가지고 오는 SimpleMetadataReader에서 class들에 대한 정보를 가지고 오기 위한 역할을 하는 클래스들이다.

 

상위 추상클래스 ClassVisitor의 메소드를 살펴보면 visit, visitSource, visitModule, visitOuterClass, visitAnnotation, visitTypeAnnotation, visitAttribute, visitInnerClass, visitEnd등등 클래스에 대한 정보를 가져올 때 사용되는 것이라는걸 확인할 수 있다.

 

이 때 에러가 발생되면서 애플리케이션이 죽냐 안죽냐가 결정이 되는걸로 봐서 이쪽에 처리가 서로 다르게 되어있을 거라고 짐작하고 더 확인해봤다.

 

우선 2.1.3 버전에 경우에는 visitEnd() 메소드를 호출할 때 에러가 발생하게 되는데 AnnotationMetadataReadingVisitor의 visitEnd 메소드는 우선 아래와 같이 되어있다.

@Override
public void visitEnd() {
   super.visitEnd();

   Class<? extends Annotation> annotationClass = this.attributes.annotationType();
   if (annotationClass != null) {
      List<AnnotationAttributes> attributeList = this.attributesMap.get(this.annotationType);
      if (attributeList == null) {
         this.attributesMap.add(this.annotationType, this.attributes);
      }
      else {
         attributeList.add(0, this.attributes);
      }
      if (!AnnotationUtils.isInJavaLangAnnotationPackage(annotationClass.getName())) {
         try {
            Annotation[] metaAnnotations = annotationClass.getAnnotations();
            if (!ObjectUtils.isEmpty(metaAnnotations)) {
               Set<Annotation> visited = new LinkedHashSet<>();
               for (Annotation metaAnnotation : metaAnnotations) {
                  recursivelyCollectMetaAnnotations(visited, metaAnnotation);
               }
               if (!visited.isEmpty()) {
                  Set<String> metaAnnotationTypeNames = new LinkedHashSet<>(visited.size());
                  for (Annotation ann : visited) {
                     metaAnnotationTypeNames.add(ann.annotationType().getName());
                  }
                  this.metaAnnotationMap.put(annotationClass.getName(), metaAnnotationTypeNames);
               }
            }
         }
         catch (Throwable ex) {
            if (logger.isDebugEnabled()) {
               logger.debug("Failed to introspect meta-annotations on " + annotationClass + ": " + ex);
            }
         }
      }
   }
}

 

여기서 annotaion 정보를 가지고 올 때 TypeNotPresentExceptionProxy에러가 동일하게 발생한다.

 

하지만 여기서 2.2.7버전과의 차이점은 이 AnnotationMetadataReadingVisitor 경우에는 에러가 발생했을 때 내부적으로 로깅만 하고 상위로 에러를 전파하지 않는다는 점이다. 그래서 결국 에러가 발생하지 않고 로깅만 되고 애플리케이션이 실행되는데 까지는 문제가 없었고 내부적으로 Sns 기능을 쓰지 않기에 문제가 없었던 것이었다.

 

 

 

그럼 이제 2.2.7버전에서는 어떤지 확인해보자. 

2.2.7에서 사용하는 SimpleAnnotationMetadataReadingVisitor의 경우에는 클래스에 정보를 얻기위해 작업하는 visit와 같은 동작들에 대해서 별도의 try catch 작업이 되어 있지 않다.

 

실제로 에러가 발생되는 visitAnnotation메소드를 보면 이 곳에서는 visitAnnotaion을 통해 정보를 가져올 때 내부적으로 MergedAnnotaionReadingVisitor visitor를 사용하지만 별도에 에러에 대한 처리가 되어 있지 않는걸 볼 수 있다. 

@Override
@Nullable
public AnnotationVisitor visitAnnotation(String descriptor, boolean visible) {
	return MergedAnnotationReadingVisitor.get(this.classLoader, this::getSource,
			descriptor, visible, this.annotations::add);
}

 

그로 인해 visitor를 통해 configuration class에 내부정보를 가져오다가 에러가 발생하게 되면 processImport에 에러가 전파되어 BeanDefinitionStoreExeption이 발생하면서 결국 application이 실행이 되지 않는 것이다.

ConfigurationClassParser클래스 내부에 processImports 코드

 

 

 

해결방법


문제가 어찌되었든 우리는 spring boot의 버전을 올려야한다. 그래서 정식으로 수정이 완료된 2.2.3버전을 사용을 하던지 또는 임시로 webmvc 라이브러리를 추가해주는 것이다.

 

 

해결방법 1.

https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-aws-messaging

// https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-aws-messaging
compile group: 'org.springframework.cloud', name: 'spring-cloud-aws-messaging', version: '2.2.3.RELEASE'

 

해결방법 2.

compile('org.springframework:spring-webmvc')

 

 

댓글()

Spring reactor 2.1.2 (netty 0.8.4) Mono.zip readTimeoutException 문제

web/Spring|2020. 7. 12. 20:34

 

Mono zip


각 Mono 처리 스레드를 병렬로 실행하고 이를 묶어서 사용할 수 있는게 Mono.zip이다. 

근데 Mono zip에서 병렬로 실행되는 작업 중 하나가 empty 또는 error가 발생 되면 바로 error 또는 complete를 내뱉게 되어있다. 하지만 각 Mono 구독 작업에 error와 empty 발생 시 문제에 대해 fallback 처리를 해주면 에러가 발생하더라도 그 로직을 타게 되어있다. 

 

하지만 2.1.2(netty 0.8.4) 버전을 사용하고 있을 때 호출 체인에서 첫 번째 요청의 실패 이후에 두 번째 요청이 정상적으로 이루어 지지 않아서 readTimeout이 발생되는 문제를 경험하였습니다.

 

이 문제를 해결하기 위해서 알아보던 중 2.1.2버전에 문제가 있는 것을 알게 되어 테스트를 해봤다.

 

 

테스트


아래 Mono.zip을 보면 두 개의 Mono 구독 작업을 병렬로 진행하도록 지정해놨고 각 작업 종료 후 response에 대한 부분을 출력하도록 해놨다.

public Mono<WedulResponse> circuitTest(WedulRequest request) {
    return Mono.zip(
        wedulClient.isWedulExist(request)
            .doOnError(e -> log.error("service error", e))
            .defaultIfEmpty(WedulResponse.builder().type("Error Return").build())
            .onErrorReturn(WedulResponse.builder().type("Error Return").build()),
        wedulTestClient.isWedulTestExist(request)
    ).map(
        d -> {
            System.out.println(d.getT2().getPage());
            System.out.println(d.getT1().getType());
            return WedulResponse.builder().isExist(d.getT1().isExist()).build();
        }
    ).doOnError(e -> log.error("error {}", e));
}

이 때 첫 번째 요청은 error가 발생하거나 empty 응답이 발생했을 때 기본값을 주도록 하고 socket timeout의 값은 1ms로 극단적으로 무조건 타임아웃이 나도록 지정해 놨다.

 

그리고 두 번째 요청http://wedul.space에서 사용중인 정상적인 api를 호출하도록 하였고 socket timeout 시간도 3000ms로 아주 넉넉하게 주었고 실제로 타임아웃이 날 이유가 없다.

 

그럼 정상적인 테스트 결과라고 한다면 아래와 같이 정상적인 응답이 와야한다. (page는 무조건 5로 나오게 지정해놨다.)

5
Error Return

 

 

실제로 응답은 예상된 대로 잘 왔다. 하지만 간혈적으로 아래와 같은 readTimeout exception이 별도로 계속 떨어졌다.

2020-07-12 20:17:30.998 ERROR 12214 --- [ctor-http-nio-3] r.netty.http.client.HttpClientConnect    : [id: 0x029e73cc, L:/127.0.0.1:63695 - R:localhost/127.0.0.1:8081] The connection observed an error

io.netty.handler.timeout.ReadTimeoutException: null

 

그래서 왜 그럴까 하고 검색을 해보니 2.1.2버전에 문제가 있어서 버전업을 하면 해결된다고 들었다. 

https://stackoverflow.com/questions/56048216/spring-webflux-timeout-with-multiple-clients

 

Spring webflux timeout with multiple clients

I have a service that interacts with a couple of other services. So I created separate webclients for them ( because of different basepaths). I had set timeouts for them individually based on https://

stackoverflow.com

 

그래서 버전을 2.2.4버전으로 업데이트하고 다시 테스트 해봤다. 실제로 아까 발생했던 readTimeoutException 문제는 더 발생하지 않았다.

 

 

실제 코드가 어떤 부분이 문제였는지는 찾지 못했지만 그래도 문제는 해결되어서 다행이다.

 

테스트 코드

https://github.com/weduls/circuit_breaker_test

댓글()

클린코드 9장 (클래스), 10장 (시스템), 11장(창발성), 12장(동시성)

JAVA/클린코드|2020. 7. 10. 09:14

클래스


  • 내부에서 동작하는 변수나 유틸리티는 protected로 선언하여 테스트에 사용하기도 한다.
  • 클래스에 기본 규칙은 작게 만드는 것. 많을수록 클래스에 대한 책임이 너무 커진다.
    SPR을 지키기 위해 클래스가 너무 많아지면 사용에 더 어렵다고 우려할 수 있으나 하나의 여러 책임을 가지고 있는 클래스를 사용하는 것 보다 더 직관적 이므로 사용하기 더 편하다.
  • 클래스 내부에 인스턴스 변수가 많아 진다는건 결국 클래스 내부에 함수와 인스턴스 변수들 사이에 응집도가 높아진다는 뜻이다. 이럴 수록 클래스를 분리해야 한다는 걸 의미한다.
  • 긴 함수를 쪼갠다 → 작은 함수 여러 개로 만든다. → 몇몇 변수와 몇몇 함수만 사용 되는 경우가 보이면 클래스로 쪼갠다.
  • 특정 기능이 변경 될 때 마다 코드가 변경되어야 하는 함수가 있다고 한다면 이는 SRP를 위반하는 행위이다. 그럴 경우 인터페이스를 만들어 기능 마다 필요한 코드를 구현하도록 하면 SRP와 OCP를 모두 위반하지 않을 수 있다.
  • 인터페이스를 선언하고 구현 클래스를 사용하는 것이 깔끔한 경우도 있으나 특정 기능이 매번 바뀌어야 하는 경우에는 변경의 위험이 있을 수 있다. 예를 들어 상황에 따라서 호출하는 api가 변경될 수 있는 경우에는 구현 클래스 레벨에서 모두 할 것이 아니라 api를 호출하는 인터페이스를 전달 받아서 처리하는 것이 더 좋다.
public interface StockExchange {
	Money currentPrice(String symbol);
}

public Portfolio {
	private StockExchange stockExchange;
	public Portfolio (StockExchange stockExchange) {
		this.stockExchange = stockExchange;
	}

	//...
}

 

 

 

 

시스템


  • 모든 애플리케이션에서 가장 중요한 부분은 관심사 분리이다.
    아래와 같은 코드의 경우 Lazy Initialization 또는 Lazy Evaluation을 사용하여 실제 필요한 순간에 할당하여 사용할 수 있다는 장점이 있으나 테스트 할 때 런타임 시에 객체 생성 로직이 합쳐져 있어서 Mock 작업도 진행해 줘야 하고 정상적으로 생성 되는지도 테스트 해야하는 두 가지의 책임이 생기기에 이는 SRP를 위반하는 행위이다. 이처럼 시스템 설정 부분과 런타임 시 필요한 부분이 연동되어 있으면 안된다. 모듈화와 관심사 분리가 잘 고려되어야 한다.
public Service getService() {
	if (this.service == null) 
		this.service = new WedulServiceImpl();
	return this.service;
}
  • Main과 application은 서로 관심사가 분리되어 있어 main은 적절하게 객체를 생성하고 application은 그 것이 잘 생성되었다는 걸 가정하에 실행하도록 하여 시스템 설정과 실행을 분리하도록 한다.
  • 객체는 인스턴스로 만드는 책임을 지지 않고 이에 대한 책임은 main이나 특수 컨테이너 제공하는 것을 DI (의존성 주입)이라고 한다.
  • 시스템은 깨끗해야하고 깨끗하지 못한 아키텍처는 도메인 논리를 흐리며 기민성을 떨어뜨린다. 도메인 논리가 흐려지면 제품 품질이 떨이지고 버그가 숨어들기 쉬워지고 생산성이 떨어진다.
  • 시스템이든 모듈이든 실제로 돌아가는 가장 단순한 수단을 사용해야 한다는 사실을 명심하자.

 

 

 

창발성


설계 규칙 4가지

 

 

모든 테스트를 실행하라.

  • 테스트를 통해 의도대로 돌아가는지 확인하는 건 당연한 역할
  • 테스트를 진행하다 보면 설계 품질은 더불어서 상승한다.
  • 결합도가 높으면 테스트가 어렵기 때문에 테스트를 작성하면서 DIP, DI, 인터페이스, 추상화 등과 같은 도구를 사용해 결합도를 낮출 수 있다.
  • 완벽한 테스트 코드를 만들고 나면 코드를 수정하는 리팩토링 과정을 거친다 하더라도 검증이 잘 되기 때문에 기존 코드가 잘 동작하지 않을거라는 불안에서 벗어 날 수 있다. 그래서 장기적으로 보나 단기적으로 보나 테스트 코드는 중요하다.
  • 핵심은 응집도를 높이고, 결합도를 낮추고, 관심사를 분리하고, 시스템 관심사를 모듈로 나누고, 함수와 클래스 크기를 줄이고, 더 나은 이름을 선택하는 것.

 

중복을 없애라

  • 같은 기능을 여러곳에서 생성하는 건 수정이 있을 때 여러곳에 작업이 필요로 하다.
  • 중복을 해결 하기 위해서는 TEMPLATE METHOD 패턴을 참고하라.
// 중복으로 들어가는 코드는 추상 클래스 내부에서 정의하고 
// 개별적으로 사용되는 부분만 abstract 메소드 선언한 뒤, 그 코드들을 공용으로 쓰는 메소드를 만들어라.



// 직원들 임금을 정하는 템플릿 클래스
public abstract class Pay {

  public int salary() {
	return commonSalary() + ratingBouns();
  }

  public int commonSalary() {
	return 100000;
  }

  abstract protected int ratingBonus();
}

// 정규직 임금
public class regularPay extends Pay {

  @Override
  protected int ratingBonus() {
	return 12321;
  }
}

// 비정규직 임금
public class temporaryPay extends Pay {
  
  @Override
  protected int ratingBonus() {
	return 21251;
  }
}

 

의도를 표현하라.

  • 표준 명칭과 가식성 좋은 이름을 사용하고 함수와 클래스 크기등을 잘 조절하여 같은 동료가 이해하기 쉽게 작성하라.

 

클래스와 메서드의 수를 최소로 줄여라

  • 클래스와 메서드 수를 줄이기 위해 무조건 인터페이스먼저 선언하고 진행을 하거나 하는 습관도 좋다.
  • 중복을 제거하고 테스트케이스를 잘 만들어 나가서 클래스와 메서드의 수를 최대한으로 줄여보자.

 

 

 

동시성


  • 대량의 데이터를 동시에 실행시키면 단일로 실행시킬 때 보다 더욱 효율적이다.
  • 원칙적으로 각 서블릿 스레드는 다른 서블릿 스레드와 무관하게 자신만의 세상에서 돌아간다.
  • 동시성은 부하를 유발할 수 있고 복잡하며 버그가 발생할 시 재현이 어렵다.
  • 동시성을 방어하기 위해서는 우선 동작 단위를 작게 하여 SRP를 꼭 지켜야 한다.
  • 그리고 임계영역을 제한하고 그 임계영역을 최대한 작게 만들어서 다른 동작에 영향 없게 설계 해야 한다.
  • ConcurrentHashMap과 같은 다중 스레드 환경에서 안전한 라이브러리를 활용하라.
  • 동기화 코드를 실행할 시 알수 없는 에러가 발생할수도 있는데 이를 단순 일회성 오류라고 생각하지 말고 실패할 수 있는 모든 경우의 테스트를 실행하라.

 

 

 

그 이후 내용은 특정 라이브러리를 개선하는 작업등이 남아있는데 이 부분은 따로 정리하지는 않는다.

결론은 기본에 충실하고 코드의 나쁜 품질을 지키기 위해서 컨벤션 정의가 필요하다고 생각된다. 결국 일은 혼자하는 것이 아니기 때문에 컨벤션 정의가 없으면 새로들어오는 사람이나 기존의 사람도 계속 코드를 유지하기는 어렵다고 판단된다. 이 기회에 이 규칙과 기존에 공부했던 내용들을 토대로 컨벤션을 한번 만들어 봐야겠다.

댓글()

클린코드 7장(경계), 8장 (단위 테스트)

JAVA/클린코드|2020. 7. 1. 09:18

 

 

경계


  • Map과 같은 공개된 인터페이스를 사용할 때 2가지 문제가 있다
    1. 전달되는 map에 clear와 같은 삭제 명령어가 있어서 전달해주는 쪽에서 알지 못하고 지워지는 이슈가 있을 수 있다.

    2. 전달된 Map 형태가 generic 하게 전해 졌어도 받는 쪽에서 Map map 등으로 받아 버린다면 캐스팅을 해서 사용하는 등의 문제나 변경의 소지가 크다. 또한 Map의 사용 방식이 변경된다면 이를 해결하기 위해 모든 부분에서 수정되어야 하는 문제가 있다.

    그래서 이를 해결하기 위해서 Map에 사용 되는 Value 값의 객체에서 Map을 품어서 쓰는 방식으로 캡슐화하여 사용하기도 한다.
public classs Sensors {
	private Map<String, Sensors> = new HashMap<>();

	public Sensor getById(String id) {
		return (Sensor) sensors.get(id);
	}

}
  • 외부 라이브러리를 사용할 경우 시간 단축에 효과가 있지만 잘못 사용함에 있어서 발생하는 영향도가 얼마나 있을지 알지 못하기 때문에 학습 테스트를 통해 외부 api에 대한 테스트를 미리 진행한다.
  • 외부 라이브러리에 대한 학습 테스트를 진행하여 사용하면 해당 라이브러리의 버전이 올라갔을 때 우리가 사용하는 목적에 맞게 정상적으로 돌아가는지 쉽게 테스트를 해볼 수 있어서 좋다.
  • Adapter pattern을 이용하여 변경의 요지가 있는 인터페이스를 방어할 수 있다.
public interface Bark {
	void speak();
}

// dog는 짖으므로 Bark 인터페이스 사용가능
public Dog implements Bark {
	@Override
	public void speak() {
		..
	}
}

// 고양이 야용 인터페이스
public interface Meow {
	void speak();
}

// 고양이는 짖기 어려움
public Cat implements Meow {
	@Override
	public void speak() {
	
	}
}

// 고양이가 짖을 수 있는 adpater 생성
public BarkCat implements Bark {
	private Meow meow;

	public BarkCat(Meow meow) {
		this.meow = meow;
	}
	
	@Override
	public void speak() {
		meow.speak();
	}
	
}

 

 

 

단위 테스트


  • 단위 테스트
    1. 실패하는 단위 테스트를 작성할 때 까지 실제 코드를 작성하지 않는다.
    2. 컴파일이 실패하지 않으면서 실행이 실패하는 정도로만 단위테스트를 작성한다.
    3. 현재 실패하는 테스트를 통과할 정도로만 실제 코드를 작성한다.

    하지만 이렇게 모두 작성하면 시간이 너무 걸려서 사실 어렵다.
  • 실제 코드가 변경될 때 마다 테스트 코드는 계속 변경의 여지가 있기에 지저분한 테스트 코드를 짜느니 없으니만 못하다. 그렇기에 실제 코드 못지 않게 중요하게 테스트 코드를 작성하라.
  • 테스트 코드 없는 실제 코드 변경은 잠정적인 버그와 같다.
  • 깨끗하고 효율성있는 테스트 코드를 작성하기 위해서는 무엇보다 중요한 건 가독성이다.
  • BUILD-OPERATE-CHECK 패턴을 사용하여 테스트 구조를 간결하게 작성한다.
  • 테스트 코드의 가독성을 위해서 실제 코드에서 지켜야 할 모든 규칙을 지킬 필요는 없다.
  • 하나의 테스트당 assert문이 많으면 좋지 않지만 그렇다고 테스트당 하나의 assert문을 사용하는건 중복코드를 양성할 수 있다. (적절하게 사용)
  • 하나의 테스트당 assert문이 많으면 좋지 않지만 그렇다고 테스트당 하나의 assert문을 사용하는건 중복코드를 양성할 수 있다. (적절하게 사용)
  • 깨끗한 테스트 코드의 FIRST 규칙
    F : 테스트는 빨라야 한다.
    I : 테스트는 서로 의존적이면 안된다.
    R : 테스트는 어떤 환경에서도 반복 가능해야 한다.
    S : 테스트는 통과 실패 두가지 검증 결과를 내보내야 한다.
    T : 단위테스트는 적시에 테스트 코드가 존재해야한다. (실제 구현 코드를 작성하기 이전에 작성되어야 한다.)

 

 

 

결론


개발을 하다보면 일정에 쫓기거나 테스트 코드 작성이 번거로워서 넘어가는 경우가 있는데 무조건 작성할 수 있도록 해야겠다. 그리고 테스트를 내가 알아볼 수 있도록 기능 동작에 중점을 주어서 했었는데 그게 결국 가독성과 재사용성을 떨어트려서 팀의 개발 속도를 저해 할수도 있다는 걸 알게 되어 조심해야겠다.

 

댓글()

클린코드 5장(객체와 자료구조), 6장 (오류처리)

JAVA/클린코드|2020. 6. 29. 11:25

 

객체와 자료구조


  • 객체에서 자료를 세세하게 공개하는 것 보다 추상화를 통해 표현하는 것이 더 좋다.
  • 객체는 동작을 공개하고 자료를 숨긴다.
  • 복잡한 시스템을 짜다보면 새로운 함수가 아니라 새로운 자료타입이 필요한 경우가 발생하는데 이 때는 클래스와 객체 지향 기법이 적합하다. 하지만 새로운 함수가 필요하다면 절차지향 코드와 자료구조 형태가 더 적합한 코드이다.

 

 

 

 

오류처리


 

  • 오류를 일일히 처리하는 것보다 차라리 예외를 던저버리는게 더 깔끔하다.
  • 확인된 예외를 처리하기 위해서 하위 메소드에서 throws를 하게되면 상위 메소드에서 이 예외에 대한 명시가 되어야 하기 때문에 하위의 예외 때문에 상위 메소드가 수정되어야 하는 불상사가 발생하기 때문에 수정에 닫혀 있어야 하다는 OCP규칙을 위반한 것이다.
  • 예외에 의미있는 내용을 함께 던져서 의미 파악에 도움이 되게 하라.
  • 에러가 발생하였을 때 null을 반환하는 코드는 일거리를 늘릴 뿐만 아니라 호출자에게 일감을 더 주게 되는 문제가 있다.
  • 에러를 모두 한 곳에서 처리하게 되면 아래와 같이 귀찮게 된다. 이를 매번 open()을 사용하는 곳에서 처리하게 되면 엄청나게 귀찮게 되고 의존성이 있어 하나의 오류가 늘어나게 되면 모든 사용하는 곳에서 처리를 해줘야 한다. 그래서 이를 별도의 클래스를 만들어서 클래스 내부에서 innerPort.open()을 실행시키게 해서 그 곳에서만 에러 내용을 처리해주고 정재된 Exception만 다시 던지게 하는 것도 방법이다.
// 문제
public void open() {
	try { 
		innerPort.open();
	} catch (DeviceResponseException e) {
		...
  } catch (NetworkErrorException e) { 
		...
  } catch (BindingException e) {
    ....
  } catch ....

} 


// 감싸기 클래스 사용
public class LocalPort {

  private ACMEPort innerPort;

  public void open() {
		try { 
			innerPort.open();
		} catch (DeviceResponseException e) {
			// 내부에서 약속된 하나의 에러 패턴을 사용.
			throw new PortDeviceFailuer(e);
	  } catch (NetworkErrorException e) { 
			throw new PortDeviceFailuer(e);
	  } catch (BindingException e) {
			throw new PortDeviceFailuer(e);
	  } catch ....
	  }
	}
}

 

 

 

 

결론

에러처리를 잘못하면 코드가 굉장히 더러워진다. 실제로 많이 경험해봤고 아직도 어렵다. 중요한건 내부에서 발생한 에러로 인해 상위에서 호출하는 함수의 코드가 변해야 하는 OCP 위반 사항을 발생시키지 않도록 하는 것 같다.

댓글()

클린코드 3장 (함수), 4장 (주석)

JAVA/클린코드|2020. 6. 20. 23:04

 

함수


- 함수를 만드는 기본 규칙은 작게 만드는 것!

 

- 함수 내부에 if 문 등의 1단이나 2단 그 이상의 중첩 구조가 발생되면 안된다.

 

- 함수의 활동은 한가지 그 이상을 하지마라.

 

- switch문에 다음과 같이 한가지 작업만 해야한다는 SRP 이론과 코드의 변경이 있으면 안된다는 OCP 규칙을 위반한다. 이를 해결하기 위해서는 다형성을 이용해서 해결해야 한다.

// 문제 코드
public int calEmployeePay(Employee e) {
	switch (e.type) {
		case SALARIED:
			return calculateSalariedPay();
		case HOURLY:
			return calculateHourlyPay();
		case .....
	}
}

// 변경 내용
public interface Employee {
	int calPay();
}


public SalaryEmployee implements Employee {
		
		@Override
		public int calPay() {
				...
		}
}

public int calEmployeePay(Employee e) {
	return e.calPay();
}

- 함수 이름이 길어지더라도 서술적으로 한방에 이해가 가능한 이름이 오히려 더 깔끔하고 좋은 코드다.

  ex) includeSetupAndTeardownPages..

 

- 함수의 인수는 기본적으로 3개 까지가 사실 마지노선이라고 생각하고 그 이상은 절대 오지 않도록 해라. 인수가 있으면 함수 자체를 이해하는데 더 어려움을 겪게 된다.

 

- 인수가 늘어난다면 별도의 인수 객체를 만들어서 묶어서 보내는 게 더 낫다.

  ex) int x, int y ⇒ Point point

 

- 함수의 이름과 인자가 한꺼번에 이해가 가능한 이름에 가장 좋다.

  ex) write(name), assertExpectedEqualsActual(expected, actual)

 

- 함수의 이름과 다른 행위를 함수안에 실행 시키지 마라 ex) checkPassword() 함수내에서 사용자 세션을 초기화 한다거나 하는 행위는 자칫하면 엄청 큰 버그를 일으킬 가능성이 크다.

 

- 에러 코드를 사용하는 것보다는 try catch를 이용해서 에러 코드를 분리하는 것이 좋고, try catch블록은 모든 영역이 아닌 별도 함수내에서 처리하도록 하는 것이 좋다.

 

- 중복된 코드를 계속 양산하지 마라.

- 모든 함수와 함수 내 모든 블록에 입구와 출구는 하나만 존재해야 한다.

 

 

 

 

주석


- 잘 작성된 주석은 이해가 되지만 경솔하고 근거없는 주석은 코드를 더 이해하기 어렵게 만든다.

 

- 주석은 코드로 의도를 표현하지 못해서 실패를 만회하기 위해 적은 코드이다. 그러므로 주석을 달고 있다면 코드를 잘 못 작성한 건 아니지 잘 생각해봐라.

 

- 주석은 언제나 코드를 따라가지 못하기 때문에 언젠가 주석은 코드와 분리되어 고아가 되어버리는 순간이 오기 때문에 조심해야 한다.

 

- 저작권 등의 정보를 알리거나 외부 라이브러리 등의 사용이나 내부 규약으로 인해 어쩔수 없이 사용하는 인자 등의 부분에 대해서 명료한 설명을 위한 주석 또는 결과 값에 대한 결과에 대한 주석 정도는 괜찮다.

 

- 누군가의 공을 달거나 HTML 주석을 위해 사용하거나 근처 코드가 아닌 다른 코드에 대한 주석 등을 다는 이런 코드들은 코드 개선에 시간을 들이는 게 더 낫고 클래스 파일에 바이트나 낭비하지 말아라.

 

 

 

결론

함수

함수는 당연히 나도 의미가 있도록 사용하기 위해서 네이밍에 많은 고민을 하고 있고 같이 일하시는 분들이 잘 이해할 수 있도록 간결하게 만들려고 노력은 하고 있다. 근데 사실 프로젝트가 커지고 하다보면 쉽지 많은 않다. 흑

 

주석

주석은 15년도에 일을 시작했을 때만해도 선배들이나 주변 개발 컨벤션에서 보면 항상 주석을 달라고 되어 있었고 오픈소스로 나와있는 라이브러리들에도 자세한 설명이 기재되어 있었다. 그래서 따라하는 습관을 들였는데 주석이 말한 그대로 코드를 따라가기 어려웠고 어느순간부터는 주석이 도움이 되는게 아니라 오히려 방해가 된다는 생각을 나 또한 들게 되어 지금은 주석대신 코드를 더 명확하게 짜기 위해서 노력하고 있다.

 

 

댓글()