노션 링크
깃허브 학습테스트

1. 어노테이션(Annotation) 이란?

1-1 설명

코드 사이에 주석처럼 쓰이며 특별한 의미, 기능을 수행하도록 하는 기술이다.

• 즉, 프로그램에게 추가적인 정보를 제공해주는 meta data라고 볼 수 있다.
• meta data : 데이터를 위한 데이터

1-2 어노테이션 사용 순서

1. 어노테이션 정의

   @Target({ElementType.[적용대상-패키지, 생성자, 메서드, 필드...]})
   // ElementType.TYPE 은 클래스,인터페이스,열거타입에 어노테이션을 붙일 수 있다는 의미
   @Retention(RetentionPolicy.[정보 유지되는 대상-소스, 런타임(보통 런타임)...])
   public @interface [어노테이션명]{
   	public 타입 elementName() [default 값]
       ...
   }

2. 클래스에 어노테이션을 배치

3. 코드가 실행되는 중에 Reflection을 이용하여 추가정보를 획득하여 기능 실시

2. 스프링 개념

2-1 스프링 MVC

1) @Controller , @RestController

@Controller

• 코드

  @Target(ElementType.TYPE)
  @Retention(RetentionPolicy.RUNTIME)
  @Documented
  @Component
  public @interface Controller {
  	@AliasFor(annotation = Component.class)
  	String value() default "";
  }

• @Component 클래스의 특수화
• 클래스 경로 스캐닝을 통해, 구현 클래스(@Component)를 자동 감지(auto-detection)
• 보통 @RequestMapping 을 함께 씀

@RestController

• 코드

  @Target(ElementType.TYPE)
  @Retention(RetentionPolicy.RUNTIME)
  @Documented
  @Controller
  @ResponseBody // 이거 하나 빼곤 Controller와 동일
  public @interface RestController {
  	@AliasFor(annotation = Controller.class)
  	String value() default "";
  }

• Spring 4.0에 도입
• @Controller + @ResponseBody 결합
• 리퀘스트 핸들링 메소드에서 @ResponseBody annotation을 쓸 필요가 없어짐!

2) @RequestMapping

• 코드

  @Target({ElementType.TYPE, ElementType.METHOD})
  @Retention(RetentionPolicy.RUNTIME)
  @Documented
  @Mapping
  public @interface RequestMapping {
  	String name() default "";
  	@AliasFor("path")//별칭 선언
  	String[] value() default {}
  	@AliasFor("value")
  	String[] path() default {};
  	RequestMethod[] method() default {};
  	String[] params() default {};
  	String[] headers() default {};
  	String[] consumes() default {};
  	String[] produces() default {};
  }
  
  //...
  
  @RestController
  @RequestMapping(value = "/api", headers = "Accept=application/json", method = GET)
  // == @GetMapping(value = "/api", headers = "Accept=application/json")
  public class PathController {...}

• @PostMapping(value = "/users", consumes = APPLICATION_JSON_VALUE)
• 매핑 종류
  • @GetMapping : 클라이언트가 서버의 리소스를 요청할 때 사용
  • @PostMapping : 클라이언트가 서버의 리소스를 수정 또는 생성할 때 사용
  • 기타 등등…(HTTP 메소드별로 존재)
• 속성
  • value : 패스 주소
  • path : 패스 주소 (@GetMapping(path = "/api") == @GetMapping("/api"))
  • params, headers : 매핑할 파라미터/ 헤더 속성 지정
  • consumes: 요청 데이터 형식! HTTP 요청의 Content-Type 헤더와 대응
  • produces: 응답 데이터 형식! HTTP 요청의 Accept 헤더와 대응

3) @ModelAttribute , @RequestBody ,@RequestParam , @PathVariable

• @ModelAttribute
  • 코드

    @Target({ElementType.PARAMETER, ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface ModelAttribute {
    	@AliasFor("name")
    	String value() default "";
    	@AliasFor("value")
    	String name() default "";
    	boolean binding() default true;
    }
    //...
    
    //요청 : http://localhost:8080/api/1
    @GetMapping
    public ResponseEntity<PathResponse> showPaths(@ModelAttribute PathsRequest pathsRequest) {
        return ResponseEntity
    				.ok(pathService.showPaths(pathsRequest));
    }

  • 뷰에서 전달된 파라미터를 JAVA 객체로 바인딩
    • 쿼리(스트링)/폼(파라미터)→ DTO
  • 요청 데이터와 Controller의 파라미터를 1:n(객체) 매핑
  • 파라미터 이름을 명시 안하면 → 해당 필드면의 Setter 호출해 데이터 바인딩
• @RequestBody
  • 코드

    @Target(ElementType.PARAMETER)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface RequestBody {
    	boolean required() default true;
    }
    
    //...
    
    // 요청 : 바디값
    @PostMapping
    public ResponseEntity<LineResponse> createLine(@RequestBody LineRequest lineRequest) {
        return ResponseEntity
                .created(URI.create("/lines"))
                .body(lineService.create(lineRequest));
    }

  • JSON 형태의 body를 JAVA 객체로 매핑
    • json 바디→ DTO/이외 객체(String…)
    • GetMapping 불가(바디 없음)
  • 기본 생성자 필수 : 직렬화
  • getter나 setter 중 1가지는 정의 : 데이터바인딩 용 필드명을 알아내기 위해
    • GET 매핑: DTO에 setter가 필요
    • POST 매핑 : DTO에 생성자 필요 (setter는 필요 X)
• @RequestParam
  • 코드

    @Target(ElementType.PARAMETER)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface RequestParam {
    	@AliasFor("name")
    	String value() default "";
    	@AliasFor("value")
    	String name() default "";
    	boolean required() default true;
    	String defaultValue() default ValueConstants.DEFAULT_NONE;
    }
    //...
    
    // 요청 : http://localhost:8080/api?stationId=1
    @DeleteMapping("/sections")
    public void deleteSection(@RequestParam long stationId) {
        lineService.deleteSection(lineId, stationId);
    }

  • HTTP 파라미터 값을 그대로 가져옴
  • 요청 데이터와 Controller의 파라미터를 1:1 매핑
  • required : 반드시 필요한 변수인지 여부
  • defaultValue : 해당 파라미터가 없을 시 디폴트 값
• @PathVariable

  @Target(ElementType.PARAMETER)
  @Retention(RetentionPolicy.RUNTIME)
  @Documented
  public @interface PathVariable 
  	@AliasFor("name")
  	String value() default "";
  	@AliasFor("value")
  	String name() default "";
  	boolean required() default true;
  
  //...
  
  @DeleteMapping("/{id}")
  public void deleteLineById(@PathVariable long id) {
      lineService.removeLineById(id);
  }

  • 메서드 파라미터 앞에 사용
  • 해당 URL에서 특정값을 변수로 받아올 수 있다.
  • required : 반드시 필요한 변수인지 여부

4) @ResponseBody, ResponseEntity

• @ResponseBody
  • 코드

    @Target({ElementType.TYPE, ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface ResponseBody {}
    
    //...
    
    @ResponseBody
    @ResponseStatus(HttpStatus.OK)
    public MoveResponseDto move(@RequestBody MoveDto moveDto) {
      return moveResponseDto;
    }

  • HTTP 규격에 맞는 응답을 만들어주기 위한 Annotation
  • HTTP 요청을 객체로 변환하거나, 객체를 응답으로 변환
  • @RestController가 붙으면 `@ResponseBody` 생략
• ResponseEntity
  • 코드

    public class ResponseEntity extends HttpEntity {
      private final Object status;
    }
    
    //...
    
    @GetMapping
    public ResponseEntity<PathResponse> showPaths(...) {
        return ResponseEntity.ok()
            .headers(...)
            .body(...);
    }

  • 응답으로 변환될 정보를 모두 담은 요소들을 객체로 만들어서 반환
  • HTTP 응답에 필요한 요소들 중 대표적인 Status, Header, Body를 지정
  • Builder 패턴을 활용

5) @ResponseStatus

@ResponseStatus(HttpStatus.BAD_REQUEST, reason = "Some parameters are invalid")

• 원하는 HttpStatus와 reason 설정
• 404 NOT FOUND, 200 OK …

6) @ExceptionHandler , @ControllerAdvice

• 코드

  @Target(ElementType.METHOD)
  @Retention(RetentionPolicy.RUNTIME)
  @Documented
  public @interface ExceptionHandler {
  	Class<? extends Throwable>[] value() default {};
  }
  
  @Target(ElementType.TYPE)
  @Retention(RetentionPolicy.RUNTIME)
  @Documented
  @Component
  public @interface ControllerAdvice {
  	@AliasFor("basePackages")
  	String[] value() default {};
  }
  
  //...
  
  @ControllerAdvice
  public class SubwayAdvice 
      @ExceptionHandler(BadRequestException.class)
      public ResponseEntity<ErrorResponse> badRequestExceptionHandler(BadRequestException e) {
           return ResponseEntity.badRequest()
  							.body(e.getMessage());
      }
  }

• @ExceptionHandler
  • 메소드 단에 붙임
  • 특정 예외(IllegalArgumentException.class 등)를 캐치하여 처리한다.
• @ControllerAdvice
  • 클래스 단에 붙임
  • 프로그램 실행 도중 예외들을 Advice클래스에서 캐치
  • 어떤 예외를 잡아낼 것인지는 Advice클래스 속 메소드 상단에 @ExceptionHandler(예외클래스명.class)를 붙여서 기술
• 실행순서
  1. 예외 터진 클래스의 @ExceptionHandler
  2. @ControllerAdvice의 @ExceptionHandler
  • 위의 메소드부터 순서대로 실행

2-2 스프링 JDBC

1) @Repository

• 코드

  @Target(ElementType.TYPE)
  @Retention(RetentionPolicy.RUNTIME)
  @Documented
  @Component
  public @interface Repository {
  	@AliasFor(annotation = Component.class)
  	String value() default "";
  }

• @Component 클래스의 특수화
• 외부I/O 처리
• DB 접근시 사용

2) NamedParameterJdbcTemplate

• 기존에 사용하던 JdbcTemplate → 가독성 낮음
• NamedParameterJdbcTemplate : ? 대신 :변수명 을 이용하여 처리 → 순서 상관없어짐
• 메소드
  1. queryForObject()
     • 코드

       public Long findIdByUserName(final String username) {
       		final String sql = "SELECT id FROM customer WHERE username = :username";
       		return namedParameterJdbcTemplate.queryForObject(sql, Map.of("username", username), Long.class);
       }

     1. queryForObject(SQL쿼리, 매핑될 파라미터, 리턴될 클래스(로우매퍼))
     2. 매핑될 파라미터 : Map<String, Object> 형태
  2. query()
     • 코드

       public List<Long> findIdsByCountry(final String country) {
       		final String sql = "SELECT id FROM customer WHERE country = :country";
       		return namedParameterJdbcTemplate.query(sql, Map.of("country", country), Long.class);
       }

     1. query(SQL쿼리, 매핑될 파라미터, 리턴될 클래스(로우매퍼))
     2. 매핑될 파라미터 : Map<String, Object> 형태
  3. update()
     • 코드

       public void updatePassword(final Long id, final String oldPassword, final String newPassword) {
               String query = "update customer set password = :newPassword"
                       + " where id = :id and password = :oldPassword";
               namedParameterJdbcTemplate.update(query, 
       						Map.of("id", id, "newPassword", newPassword, "oldPassword", oldPassword)
       				);
       }

     1. update(SQL쿼리, 매핑될 파라미터)
  4. batchUpdate()
     • 코드

       public int[] deleteByIds(final List<Long> ids) {
           final String query = "DELETE FROM cart_item WHERE id = :id";
           List<Map<String, Long>> updateMaps = ids.stream()
                   .map(id -> Map.of("id", id))
                   .collect(Collectors.toList());
           SqlParameterSource[] batchArgs = SqlParameterSourceUtils.createBatch(updateMaps);
           return jdbcTemplate.batchUpdate(query, batchArgs);
       }

     1. batchUpdate(SQL쿼리, 매핑될 파라미터 리스트)
     2. 매핑될 파라미터 리스트 : SqlParameterSource[] 형태
        1. SqlParameterSourceUtils.createBatch() 를 통해 생성
• GeneratedKeyHolder
  • 코드

    public Long create(final Long customerId, final Long productId) {
        final String query = "INSERT INTO cart_item(customer_id, product_id, quantity) VALUES (:customer_id, :product_id, :quantity)";
    
        Map<String, Object> params = new HashMap<>();
        params.put("customer_id", customerId);
        params.put("product_id", productId);
        params.put("quantity", 1);
    
        SqlParameterSource source = new MapSqlParameterSource(params);
    
        final KeyHolder keyHolder = new GeneratedKeyHolder();
        jdbcTemplate.update(query, source, keyHolder);
        return keyHolder.getKey().longValue();
    }

  • 자동으로 auto increment에 의해 생성된 id를 반환할 수 있도록 함
• ROW_MAPPER
  • 코드

    RowMapper<User> ROW_MAPPER = (resultSet, rowNum) -> new User(
                         resultSet.getString("name"),
                         resultSet.getString("description")
                       ));

  • 행 별로 JdbcTemplate 매핑하는 데 사용되는 인터페이스
  • RowMapper<GuestBook> rowMapper = BeanPropertyMapper.newInstance(GuestBook.class);
    의 형태로 사용 가능

2) @Transactional

• 코드

  //게시판의 게시글을 삭제하는 메서드 
  @Transactional
  public void removeBoard(Long id) throws Exception { 
  		replyDAO.removeAll(id); //삭제할 게시글의 답글 삭제 
  		boardDAO.deleteBoard(id); //게시글 삭제 
  }

• DB 트랜잭션을 설정하고 싶은 클래스나 메소드에 적용
• 클래스, 메서드 모두에 적용??
  • 메서드 레벨의 @Transactional선언이 우선 적용!
• method 내부에서 일어나는 DB 로직이 전부 성공하거나, DB 접근중 하나라도 실패하면 전체 롤백
• 일반적으로 DB 데이터를 등록/수정/삭제 하는 Service 메소드는 @Transactional를 필수적으로 가져간다.
• @Transaction(readOnly=true, rollbackFor=Exception.class)
  • readOnly : 읽기 전용
  • rollbackFor : 해당 Exception이 생기면 롤백
• 주의사항
  • 해당 어노테이션 붙여도 롤백 안됨!
    • WebEnvironment의 RANDOM_PORT, DEFINED_PORT
    • DB의 id (Auto Increment 옵션 사용 시)
  • 이미 @Transaction적용됨!
    • @JdbcTest

2-3 스프링 CORE

개념) DI/IoC

[10분 테코톡] 오찌, 야호의 DI와 IoC

• 코드

  @Service
  public class LineService {
      private final LineRepository repository;
  		//자동으로 DI(생성자 주입)됨!!
      public LineService(LineRepository repository) {
          this.repository = repository;
      }
  }

• IoC 원칙이란?
  • 제어의 역전
  • 할리우드 원칙 : 주도권을 빼앗기고, 호출 당하기를 기다리는 모습…
  • 기존엔 내부에서 의존을 관리했지만, 이제 외부에서 의존을 주입받도록 변경
  • DIP (Dependency Inversion Principle, 의존성 역전 원칙) 원칙과 함께 사용되길 권장됨
• DI란?(Dependency Injection)
  • 의존성 주입 : 객체 간 의존성을 외부에서 주입 후 관리
  • 장점
    • 깔끔한 코드
    • 클래스를 테스트하기 쉬워짐
    • 객체 간 의존성을 줄여줌
    • 코드의 재사용성 증가
• DI의 세 가지 방식
  • 생성자 주입
    • 생성자로 의존성 주입
    • 필드 주입에 비해, 객체지향 원칙중 단일책임 원칙을 위반할 소지가 덜함
    • DI Container에 덜 의존
    • 필드를 final로 선언→ 불변 객체
    • 순환의존 방지
  • setter 주입
  • 필드 주입(@Autowired)

1) @Bean(@Configufation), @Component

• @Bean
  • 코드

    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Component //@Configuration은 @Component을 포함한다!!!
    public @interface Configuration {...}
    
    @Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface Bean {...}

  • 메소드 리턴 객체을 Bean으로 등록
  • @Configuration 을 클래스에 붙인 후 사용!
  • 개발자가 직접 제어가 불가능한 외부 라이브러리등을 Bean으로 만들려할 때 사용
    • 예) ObjectMapper Class에 @Component를 선언할수는 없으니
      • ObjectMapper의 인스턴스를 생성하는 메소드를 만들고
      • 해당 메소드에 @Bean을 선언하여 Bean으로 등록한다.
• @Component
  • 코드

    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Indexed
    public @interface Component {...}

  • 클래스 객체를 Bean으로 등록
  • 개발자가 직접 컨트롤이 가능한 클래스의 경우 사용

2) @ComponentScan

• 코드

  @Retention(RetentionPolicy.RUNTIME)
  @Target(ElementType.TYPE)
  @Documented
  @Repeatable(ComponentScans.class)
  public @interface ComponentScan {...}

• @Component, @Service, @Repository, @Controller, @Configuration이 붙은 빈들을 찾아서 Context에 등록
• @Bean 대신 @Controller, @Service, @Repository등을 사용하는 이유
  • 가독성
  • @Repository 에서는 unchecked exception들을 스프링의 DataAccessException으로 처리…

3) @SpringBootApplication

• 코드

  @Target(ElementType.TYPE)
  @Retention(RetentionPolicy.RUNTIME)
  @Documented
  @Inherited
  //------중요------
  @SpringBootConfiguration
  @EnableAutoConfiguration
  @ComponentScan(excludeFilters = { 
  		@Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
  		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) 
  })
  //---------------
  public @interface SpringBootApplication {
  	...
  }

  [10분 테코톡] 🦆러너덕의 Springboot autoConfiguration : 링크
  

• @SpringBootApplication 속 3가지 어노테이션

  1. @SpringBootConfiguration

  • @Configuration과 같은 기능. bean을 만들어줌

    2. @EnableAutoConfiguration

  • 예시 사진
    

  • 외부 라이브러리 속 spring.factories 속 Configuration들(리소스 안에 우리가 등록해둔 빈들 포함)을 자동 등록

    • 이때, AutoConfiguration 의 등록 조건을 만족하는 경우에만 등록!

  • -debug 옵션으로 jar파일을 실행 : 조건 만족 여부, Bean 등록리스트 확인

  • IntelliJ에서는 별도의 설정 없이 Actuator 의 기능을 제공 → 등록된 Bean 확인

    3. @ComponentScan

  • (base-package가 정의되지 않으면)

  • 해당 어노테이션이 붙은 classpath 하위의 @Component 들을 스캔, Bean으로 등록

2-4 스프링 MVC Config

개념) AOP

• 인프라 로직(부가기능)은 중복로직…!
• 비즈니스 로직과 분리하자~~!!!
• Interceptor도 일종의 AOP?->더 알아보기

1) Interceptor

• 코드

  @Configuration
  public class WebConfig implements WebMvcConfigurer {
      @Override
      public void addInterceptors(InterceptorRegistry registry) {
          registry.addInterceptor(createTokenInterceptor())
                  .addPathPatterns("/auth/**");
      }
  }
  
  //...
  
  public class TokenInterceptor implements AsyncHandlerInterceptor {
  
      private final JwtTokenProvider jwtTokenProvider;
  
      public TokenInterceptor(final JwtTokenProvider jwtTokenProvider) {
          this.jwtTokenProvider = jwtTokenProvider;
      }
  
      @Override
      public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
          String accessToken = AuthorizationExtractor.extract(request);
          if (!jwtTokenProvider.validateToken(accessToken)) {
              throw new AuthorizationException("토큰이 유효하지 않습니다.");
          }
          return true;
      }
  }

• Dispatcher이 실행된 후, 핸들러의 실행을 가로챈다
• 컨트롤러의 요청, 응답을 가로채는 역할
• preHandle : 컨트롤러 호출 전 실행 / 리턴값이 false일 시 작업중단
• postHandle : 컨트롤러 실행 후 호출/ view 생성 전
• afterCompletion : 최종 view 실행 후 실행됨

2) ArgumentResolver

• 코드

  //1. 설정 클래스에서 ArgumentResolver 추가 구현(WebMvcConfigurer) 활용
  @Configuration
  public class AuthenticationPrincipalConfig implements WebMvcConfigurer {
      @Override
      public void addArgumentResolvers(List argumentResolvers) {
          argumentResolvers.add(createAuthenticationPrincipalArgumentResolver());
      }
  
      @Bean
      public AuthenticationPrincipalArgumentResolver createAuthenticationPrincipalArgumentResolver() {
          return new AuthenticationPrincipalArgumentResolver(jwtTokenProvider);
      }
  }
  
  //2. 매핑할 메소드 인자에 붙일 어노테이션 만들기
  @Target(ElementType.PARAMETER)
  @Retention(RetentionPolicy.RUNTIME)
  public @interface AuthenticationPrincipal {
  }
  
  //3. 클래스 안에서 resolveArgument메소드로 객체 매핑
  public class AuthenticationPrincipalArgumentResolver implements HandlerMethodArgumentResolver {
  
      private final JwtTokenProvider jwtTokenProvider;
  
      public AuthenticationPrincipalArgumentResolver(final JwtTokenProvider jwtTokenProvider) {
          this.jwtTokenProvider = jwtTokenProvider;
      }
  
      @Override
  		//매핑을 위해 사용할 클래스 입력
      public boolean supportsParameter(MethodParameter parameter) {
          return parameter.hasParameterAnnotation(AuthenticationPrincipal.class);
      }
  
      @Override
  		//객체 매핑
      public Object resolveArgument(MethodParameter parameter,
                                    ModelAndViewContainer mavContainer,
                                    NativeWebRequest webRequest,
                                    WebDataBinderFactory binderFactory) {
          HttpServletRequest httpServletRequest = (HttpServletRequest) webRequest.getNativeRequest();
          String payload = jwtTokenProvider.getPayload(AuthorizationExtractor.extract(httpServletRequest));
          return new TokenRequest(Long.parseLong(payload));
      }
  }

• 리퀘스트 값→객체 매핑을 담당
• HandlerMethodArgumentResolver 인터페이스
  • supportsParameter : 리퀘스트 메소드의 인자에 원하는 어노테이션이 붙어있는지 확인(그대로 사용)
  • resolveArgument : 특정 어노테이션이 붙어있는 메서드의 parameter를 원하는 형태로 정보를 바인딩하여 반환

2-5 스프링 Auth

• 내일 작성…
• 아니면 27일 작성…

1) sessionLogin —

2) tokenLogin —