이번 강의에서는 스프링 빈을 어떻게 등록하고, 의존관계가 어떻게 설정되는지 알아볼 것이다.

컴포넌트 스캔과 자동 의존관계 설정

Spring 이 실행 될 때, Spring Container 라는 통이 하나 생긴다. 그 안에 @Controller 라는 어노테이션이 있으면, 해당 어노테이션을 가진 객체를 생성해서 Spring 에 넣어준다. 그리고 Spring 에서 관리해준다. 스프링 입문(3) 회원 관리 예제-백엔드 개발 에서 작성한 MemberController 를 기반으로 설명할 예정이다.

회원 컨트롤러에 의존관계 추가

회원 컨트롤러(MemberController)가 회원 서비스와 회원 리포지토리를 사용할 수 있도록 의존 관계를 준비할 것이다.

1. MemberService에 @Autowired 붙여주기

  package com.hello.hellospring.controller;

  import com.hello.hellospring.service.MemberService;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.stereotype.Controller;

  @Controller
  public class MemberController {

      private final MemberService memberService;

      // @Autowired 는 Spring container에서 MemberService를 가져온다.
      @Autowired
      public MemberController(MemberService memberService) {
          this.memberService = memberService;
      }
  }

• 생성자에 @Autowired 가 있으면 스프링이 연관된 객체를 스프링 컨테이너에서 찾아서 넣어준다. 이렇게 객체 의존관계를 외부에서 넣어주는 것을 의존성 주입, DI(Dependency Injection) 이라고 한다.
• 스프링 입문(3) 회원 관리 예제-백엔드 개발 에서는 개발자가 직접 주입했고, 여기서는 @Autowired 에 의해 스프링이 주입해준다.
  

2. 회원 서비스 스프링 빈 등록

   • MemberService 클래스에 @Service 어노테이션 붙여주기
   • MemberController 안의 MemberService에 @Autowired 를 붙여줬다고 해서, 의존성 관계가 바로 연결되지 않는다.
   • MemberService 클래스에 @Service 어노테이션을 붙여줘야지만 스프링 빈으로 자동 등록되어 자동 의존관계가 설정되는 것이다.

    package com.hello.hellospring.service;

    import com.hello.hellospring.domain.Member;
    import com.hello.hellospring.repository.MemberRepository;
    import org.springframework.stereotype.Service;

    import java.util.List;
    import java.util.Optional;

    @Service
    public class MemberService {

    private final MemberRepository memberRepository;

    public MemberService(MemberRepository memberRepository) {
        this.memberRepository = memberRepository;
    }

3. 회원 리포지토리 스프링 빈 등록

    @Repository
    public class MemoryMemberRepository implements MemberRepository {}

이제 위 세가지 과정을 통해, MemberService 와 MemberRepository 가 스프링 컨테이너에 스프링 빈으로 등록되었다.

참고 : 스프링은 스프링 컨테이너에 빈을 등록할 때, 기본적으로 싱글톤으로 등록한다. ( 유일하게 하나만 등록해서 그 객체를 공유 ) 따라서 같은 스프링 빈이라면 모두 같은 인스턴스다. 설정을 통해 싱글톤이 아니게 설정할 수 있지만, 특별한 경우를 제외하고 대부분 싱글톤을 사용한다.

스프링 빈 등록 방법

스프링 빈을 등록하는 데에는 2가지 방법이 있다.

• 컴포넌트 스캔과 자동 의존관계 설정
• 자바 코드로 직접 스프링 빈 등록

회원 컨트롤러에 의존관계 추가 에서는 컴포넌트 스캔을 통해 자동 의존관계를 등록한 것이다.

컴포넌트 스캔 원리

1. @Component 어노테이션이 있으면 스프링 빈으로 자동 등록된다.
2. @Controller, @Service, @Repository 모두 @Component를 포함하고 있기 때문에, 해당 어노테이션을 붙여주면 스프링 빈으로 자동 등록되는 것이다.

실무에서는 주로 정형화된 컨트롤러, 서비스, 리포지토리 같은 코드는 컴포넌트 스캔을 사용한다. 그리고 정형화되지 않거나, 상황에 따라 구현 클래스를 변경해야 하는 경우라면 설정을 통해서 직접 자바 코드로 스프링 빈을 등록한다.

해당 강의에서는, 향후 MemoryMemberRepository 를 다른 리포지토리로 변경할 예정이므로, 컴포넌트 스캔 방식 대신에 자바 코드로 스프링 빈을 설정하겠다.

자바 코드로 직접 스프링 빈 등록

이번에는 직접 자바 코드를 통해서 스프링 빈을 등록해 볼 것이다.

1. 먼저 회원 서비스와 회원 리포지토리의 @Service, @Repository , @Autowired 어노테이션을 제거한다.
2. SpringConfig 클래스를 만들고, 아래와 같이 코드를 작성한다.

package com.hello.hellospring;

import com.hello.hellospring.repository.MemberRepository;
import com.hello.hellospring.repository.MemoryMemberRepository;
import com.hello.hellospring.service.MemberService;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


/*
    @Configuration 을 통해 spring이 뜰 때 @Configuraiton을 읽고 MemberService를 스프링빈에 등록해준다.
 */
@Configuration
public class SpringConfig {

    @Bean
    public MemberService memberService() {
        return new MemberService(memberRepository());
    }

    @Bean
    public MemberRepository memberRepository() {
        return new MemoryMemberRepository();
    }

}

• @Configuration 과 @Bean 어노테이션을 통해 스프링 빈으로 등록이 가능하다.
• @Configuration 을 통해 spring이 뜰 때 @Configuraiton 을 읽고 MemberService 를 스프링 빈으로 등록해준다.

Java에서 HashMap 정렬이 필요할 때, 그 방법에 대해 알아볼 것이다.

정렬 기준은 key, value 두가지로 나눌 수 있다.

1. Key 값을 기준으로 정렬하기

map 의 keySet을 이용하여 정렬한다. 오름차순 시에는 Collection.sort(), 내림차순 시에는 Collection.reverse() 메소드를 사용하여 정렬한다.

import java.util.*;

public class Sort {

    public static void main(String[] args) {

        Map<String, Integer> map = new HashMap<>();

        map.put("A", 10);
        map.put("D", 30);
        map.put("C", 20);
        map.put("B", 40);


        List<String> keySet = new ArrayList<>(map.keySet());

        // 키 값으로 오름차순 정렬
        Collections.sort(keySet);

        for (String key : keySet) {
            System.out.print("Key : " + key);
            System.out.println(", Val : " + map.get(key));
        }

        /*  결과
            Key : A, Val : 10
            Key : B, Val : 40
            Key : C, Val : 20
            Key : D, Val : 30
         */



        // 키 값으로 내림차순 정렬
        Collections.reverse(keySet);

        for (String key : keySet) {
            System.out.print("Key : " + key);
            System.out.println(", Val : " + map.get(key));
        }

        /*  결과
            Key : D, Val : 30
            Key : C, Val : 20
            Key : B, Val : 40
            Key : A, Val : 10
        */
    }
}

2.Value 값을 기준으로 정렬하기

Value 값을 기준으로 정렬할 때는 comparator를 사용하여 정렬한다.

comparator는 람다 표현식으로 간단하게 표현할 수도 있다.

import java.util.*;

public class Sort {

    public static void main(String[] args) {

        Map<String, Integer> map = new HashMap<>();

        map.put("A", 10);
        map.put("D", 30);
        map.put("C", 20);
        map.put("B", 40);


        List<String> keySet = new ArrayList<>(map.keySet());

        // Value 값으로 오름차순 정렬
        keySet.sort(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return map.get(o1).compareTo(map.get(o2));
            }
        });

        for (String key : keySet) {
            System.out.print("Key : " + key);
            System.out.println(", Val : " + map.get(key));
        }

        /*
            결과
            Key : A, Val : 10
            Key : C, Val : 20
            Key : D, Val : 30
            Key : B, Val : 40
         */

        // Value 값으로 내림차순 정렬
        // 위 comparator 람다 표현식으로
        keySet.sort((o1, o2) -> map.get(o2).compareTo(map.get(o1)));

        for (String key : keySet) {
            System.out.print("Key : " + key);
            System.out.println(", Val : " + map.get(key));
        }

        /* 결과
            Key : B, Val : 40
            Key : D, Val : 30
            Key : C, Val : 20
            Key : A, Val : 10
         */
    }
}

더 많은 방법이 있으나 가장 간단하게 정렬할 수 있는 방법을 알아보았다.

이번 포스팅에서는 간단한 회원 관리에 대한 비즈니스 요구사항을 실제 코드로 구현해 볼 것이다. 구현 후 테스트 코드까지 작성한다.

비즈니스 요구사항 정리

현재 비즈니스 요구사항은 아래 세가지이다.

• 데이터 : 회원 ID, 이름
• 기능 : 회원 등록, 조회
• 아직 DB 는 선정되지 않았다고 가정

웹 애플리케이션 계층 구조

일반적인 웹 애플리케이션 계층 구조는 다음과 같다. 아래와 같은 구조로 코드를 작성할 예정이다.

• 컨트롤러 : 웹 MVC의 컨트롤러 역할이다.
• 서비스 : 핵심적인 비즈니스 로직을 구현한다.
• 리포지토리 : 실제 DB에 접근하고 도매인 객체를 DB에 저장하고 관리한다.
• 도메인 : 비즈니스 도메인 객체이다. Ex) 회원, 주문, 쿠폰 등등 (Model 과 비슷한 개념일까..?)

클래스 의존관계 설정

• 아직 DB가 선정되지 않아서, 인터페이스를 통해 구현 클래스를 변경할 수 있도록 설계한다.
• DB는 RDB, NoSQL 등 다양한 저장소를 고민하는 상황으로 가정한다.
• 개발 진행을 위해 초기 개발 단계에서는 구현체로서 가벼운 메모리 기반의 DB를 사용할 것이다.

회원 도메인과 리포지토리 만들기

1. 회원 객체
   • 비즈니스 요구사항인 id, name 값을 갖는 Member 객체 생성

   package com.hello.hellospring.domain;

   public class Member {

       private Long id;
       private String name;

       public Long getId() {
           return id;
       }

       public void setId(Long id) {
           this.id = id;
       }

       public String getName() {
           return name;
       }

       public void setName(String name) {
           this.name = name;
       }
   }

2. 회원 리포지토리 인터페이스

   package com.hello.hellospring.repository;
   
   import com.hello.hellospring.domain.Member;
   
   import java.util.List;
   import java.util.Optional;
   
   public interface MemberRepository {
   
       Member save(Member member);
       Optional<Member> findById(Long id);
       Optional<Member> findByName(String name);
       List<Member> findAll();
   
   }

   • Optional : java 8의 기능 중 하나이며, 가져오는 값이 Null 일 때를 대비해 Optional 객체로 감싸서 return 한다.
     • Null 값 return 을 막을 수 있다.

3. 회원 리포지토리 메모리 구현체

   package com.hello.hellospring.repository;

   import com.hello.hellospring.domain.Member;
   import java.util.*;

   public class MemoryMemberRepository implements MemberRepository {

       // 실무에서는 동시성 문제가 있어서 아래처럼 공유되는 변수일 때는 HasnMap 이 아닌 ConcurrentHashMap 을 쓴다.
       private static Map<Long, Member> store = new HashMap<>();
       // key 값 생성
       private static long sequence = 0L;

       @Override
       public Member save(Member member) {
           member.setId(++sequence);
           store.put(member.getId(), member);
           return member;
       }

       @Override
       public Optional<Member> findById(Long id) {
           return Optional.ofNullable(store.get(id));
       }

       @Override
       public Optional<Member> findByName(String name) {
           return store.values().stream()
                   .filter(member -> member.getName().equals(name))
                   .findAny();
       }

       @Override
       public List<Member> findAll() {
           return new ArrayList<>(store.values());
       }

       // Test code에서 사용
       public void clearStore() {
           store.clear();
       }
   }

• 실무에서는 동시성 문제를 고려하여 HashMap 대신 ConcurrentHashMap, AtomicLong 사용을 고려한다.

회원 리포지토리 테스트 케이스 작성

개발한 기능을 테스트할 때는 자바의 main 메소드 혹은 컨트롤러를 통해서 실행할 수 있다. 이러한 방법은 몇가지 단점이 있다.

• 준비하고 실행하는 데 오래 걸림
• 반복 실행 어려움
• 여러 테스트를 한번에 실행하기 어려움

따라서 Java에서는 JUnit 이라는 프레임 워크를 사용하여 테스트를 진행한다.

Test 케이스를 먼저 만들고, 이후 비즈니스 로직이나 repository를 구현하는 경우도 있다. 이것이 Test-Driven-Development(TDD) 테스트 주도 개발이다!

Junit 으로 테스트 케이스 작성하기

1. src/test/java 하위 폴더에 생성한다.
2. @Test 어노테이션을 메소드 위에 붙여주면 끝!

Test Case 작성 시 유의점

• 네이밍

  • 보통 Test Class 네이밍은 테스트 하고자 하는 클래스명 뒤에 Test 를 붙인다.
  • 테스트 메소드명은 직관적으로 한글로 적기도 한다. Build 시에 test 코드는 포함되지 않는다.

• 검증 방법

  • try~catch 를 이용하여 테스트할 수도 있으나, junit 혹은 assertj 를 통해 검증할 수 있다.
    • Junit : Assertions.assertEquals 으로 검증
    • assertj : Assertions.assertThat(비교대상).isEqualTo(결과값) 로 검증
  • 이외에도 많은 메소드들이 존재함

• 테스트의 독립성

  • 테스트는 각각 독립적으로 실행되어야 한다. 다시 말해서 모든 테스트는 순서 관계없이 모두 정상적으로 동작해야 한다.
    • 테스트 순서에 의존관계가 있는 것은 좋은 테스트가 아니다.
    • 한번에 여러 테스트를 실행했을 때 메모리 DB에 직전 테스트 결과가 남을 수 있기 때문에 @AfterEach 를 사용하여 데이터를 삭제해준다.
      • @AfterEach : 각 테스트가 종료될 때마다 이 기능을 실행한다.

• Given - When - Then 패턴

  • Given : 테스트에서 구체화하고자 하는 행동을 시작하기 전에 테스트 상태를 설명하는 부분
  • When : 구체화하고자 하는 그 행동
  • Then : 어떤 특정한 행동 때문에 발생할 것으로 예상되는 변화에 대한 설명

package com.hello.hellospring.repository;

import com.hello.hellospring.domain.Member;
//import org.junit.jupiter.api.Assertions;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;

import java.util.List;
import java.util.Optional;

import static org.assertj.core.api.Assertions.*;

class MemoryMemberRepositoryTest {

    MemoryMemberRepository repo = new MemoryMemberRepository();

    // 각 테스트 메소드들이 끝나면 실행되도록! 여기서는 repo를 초기화해주자
    @AfterEach
    public void afterEach(){
        repo.clearStore();
    }

    @Test
    public void save() {
        Member member = new Member();
        member.setName("spring");

        repo.save(member);

        Member result = repo.findById(member.getId()).get();

//        Assertions.assertEquals(member, result);                    > junit
//        Assertions.assertThat(member).isEqualTo(result);  > assertj

        // member가 result와 같니?
        assertThat(member).isEqualTo(result);

        /* 
           참고 : assertThat 은 static이기 때문에, static import 로 선언해주면 위처럼 Assertions를 안써도 됨
        */
    }

    @Test
    public void findByName() {
        Member member1 = new Member();
        member1.setName("spring1");
        repo.save(member1);

        Member member2 = new Member();
        member2.setName("spring2");
        repo.save(member2);

        Member result = repo.findByName("spring1").get();
        assertThat(result).isEqualTo(member1);
    }

    @Test
    public void findAll() {
        Member member1 = new Member();
        member1.setName("spring1");
        repo.save(member1);

        Member member2 = new Member();
        member2.setName("spring2");
        repo.save(member2);

        List<Member> result = repo.findAll();
        assertThat(result.size()).isEqualTo(2);
    }
}

회원 서비스 개발

회원 리포지토리 개발을 테스트 케이스를 통해 검증을 마쳤다면, 서비스단을 구현한다.

• join() - 회원가입
• validateDuplicateMember() - 이름 중복 회원 존재 여부 판단
• findMembers() - 전체 회원 조회
• findOne() - 회원 한명 조회

package com.hello.hellospring.service;

import com.hello.hellospring.domain.Member;
import com.hello.hellospring.repository.MemberRepository;

import java.util.List;
import java.util.Optional;

public class MemberService {

    // DI
    private final MMemberRepository memberRepository;
    public MemberService(MemberRepository memberRepository) {
        this.memberRepository = memberRepository;
    }

    /**
     *  회원 가입
     *  같은 이름의 중복 회원 안됨
     */
    public Long join(Member member) {

        validateDuplicateMember(member); // 중복 회원 검증
        memberRepository.save(member);
        return member.getId();
    }

        /**
         *  중복 회원 검증
         *    findByName(member.getName()) 의 Return type 은 Optional 이다.
         *  Optional 객체는 ifPresent 메소드를 통해 값 존재 여부 판단이 가능하다.
     *  이 코드에서는 이름이 중복되는 경우 Exception 반환한다!
     */
    private void validateDuplicateMember(Member member) {
        memberRepository.findByName(member.getName())
                .ifPresent(m -> {
                    throw new IllegalStateException("이미 존재하는 회원입니다");
                });
    }

    /**
     *  전체 회원 조회
     *  repository 같은 경우는 메소드명 작성 시 데이터 넣고빼는 느낌
     *  service 단 부터는 좀더 비즈니스적인 직관적 네이밍 하자!
     */
    public List<Member> findMembers() {
        return memberRepository.findAll();
    }

    public Optional<Member> findOne(Long memberId) {
        return memberRepository.findById(memberId);
    }

}

회원 서비스 테스트

회원 리포지토리의 코드가 회원 서비스 코드를 DI(Dependency Injection) 가능하도록 한다.

테스트 코드 작성 시 정상 Flow도 고려해야 하지만, 예외의 경우를 더욱 신경써줘야 한다.

package com.hello.hellospring.service;

import com.hello.hellospring.domain.Member;
import com.hello.hellospring.repository.MemoryMemberRepository;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import java.util.Optional;

import static org.assertj.core.api.Assertions.*;
import static org.junit.jupiter.api.Assertions.*;

class MemberServiceTest {

//    MemberService memberService = new MemberService();
//    MemoryMemberRepository memberRepository = new MemoryMemberRepository();

    /*
        지금 위의 MemberService 에서 선언된 MemoryMemberRepository 와
        테스트 클래스에 선언된 memberRepository 는 다른 인스턴스이다.
        만약 서비스단의 repository 가 static이 아니라면 에러가 날 수 있다.
        >> Memberservice 에서 memberrepository를 외부에서 넣어주도록 생성자를 만든다. (DI)
     */

    MemberService memberService;
    MemoryMemberRepository memberRepository;

    @BeforeEach
    public void beforeEach() {
        memberRepository = new MemoryMemberRepository();
        memberService = new MemberService(memberRepository);
    }


    @AfterEach
    public void afterEach(){
        memberRepository.clearStore();
    }


    @Test
    void 회원가입() {

        // given
        Member member = new Member();
        member.setName("hello");

        // when : 뭘 검증할거냐 > 회원가입
        Long saveId = memberService.join(member);

        // then : 회원가입 한 id 가 처음에 주어진 id 와 같야?
        Member findMember = memberService.findOne(saveId).get();
        assertThat(member.getName()).isEqualTo(findMember.getName());
    }

    /*
        위 회원가입은 너무 단순함!
        테스트는 정상 flow도 중요하지만 예외 flow도 매우 중요하다.
     */

    @Test
    public void 중복_회원_예외() {

        // given >> 이름이 같은 회원 두명이 있다.
        Member member1 = new Member();
        member1.setName("spring");

        Member member2 = new Member();
        member2.setName("spring");

        // when >> 이름 같은 회원 가입해보자
        memberService.join(member1);

        // try catch 로도 검증할 수 있지만, assertThrows를 이용해 보자
        /*
            try {
                memberService.join(member2);
                // 만약 catch에 안걸리고 아래 코드가 수행된다면
                fail();
            } catch (IllegalStateException e) {
                assertThat(e.getMessage()).isEqualTo("이미 존재하는 회원입니다");
            }
        */

        // memberService.join(member2) 실행 시 IllegalStateException이 발생하는가?
        assertThrows(IllegalStateException.class, () -> memberService.join(member2));
        IllegalStateException e = assertThrows(IllegalStateException.class, () -> memberService.join(member2));
        assertThat(e.getMessage()).isEqualTo("이미 존재하는 회원입니다");

    }

}

이번 강의에서는 웹 개발하는 방법을 크게 세가지로 나누고 정리해 보았다. 크게 정적 컨텐츠, MVC와 템플릿 엔진, API 방식이 있다.

정적 컨텐츠

• 정적 컨텐츠는 서버에서 처리하는 것 없이, html 파일 그대로를 웹 브라우저에 전달한다.
• 스프링 공식 문서 에 나와 있듯이, /resource/static 폴더 안의 html을 spring 내에서 읽어서 바로 띄워줄 수 있다.
• http://localhost:8080/hello-static.html 로 접속하면 컨트롤러를 타지 않고 바로 hello-static.html을 띄워준다.

MVC 와 템플릿 엔진

• 서버단에서 html을 동적으로 변경하여 웹 브라우저로 전달한다. 예를 들면 jsp

• Model, View, Controller(MVC 패턴)

  • View 는 화면을 그리는 것에만 모든 역량을 집중해야 한다.
  • Controller 는 비즈니스 로직에 집중해야 한다.

• 요즘의 개발 패턴이나, 이미 레거시하다.

• controller 에서 ViewResolver로 던진다

  @GetMapping("hello-mvc") 
  public String helloMvc(@RequestParam("name") String name, Model model) {
    model.addAttribute("name", name); // hello-template.html에 name을 동적으로 넣어주고 웹 브라우저로 반환 
    return "hello-template"; 
  }

API

• 안드로이드, IOS 등 개발 시 JSON 구조의 포맷으로 클라이언트에게 데이터를 전달한다.

• Vue, React 등의 클라이언트 혹은 서버끼리 통신 시에도 사용된다.

• @ResponseBody 가 붙어있다면 ViewResolver에게 보내지 않고 그대로 데이터를 return 한다. ( return 내용을 http body부에 직접 넣어줌)

  @GetMapping("hello-api") 
  @ResponseBody public Hello helloApi(@RequestParam("name") String name) { 
      Hello hello = new Hello(); 
      hello.setName(name); 
      return hello; 
  } 

  static class Hello { 
      private String name; 

      /*  getter setter 
          java bean 표준 방식 or property 접근 방식 이라고 부름 
      */ 
      public String getName() { 
          return name;
      } 
      public void setName(String name) { 
          this.name = name; 
      } 
  }

• return 값이 객체인 경우 Default가 JSON 방식이기 때문에 JSON 데이터로 변환하여 http 응답으로 return 한다.
  • 단순 문자인 경우 StringConverter(StringHttpMessageConverter) 동작, 객체인 경우 JsonConverter(MappingJackson2HttpMessageConverter) 가 동작한다.
    • 객체를 JSON으로 변환해주는 라이브러리는 크게 두가지(Jackson, Gson > spring 기본은 Jackson이다)
    • byte 처리 등, 기타 여러 HttpMessageConverter가 기본으로 등록되어 있다.

회고

이미 알고 있는 내용이지만 개념적으로 정리하는 시간이라서 좋았다. 빨리 완강하고 더 깊이있는 내용을 공부하고 싶다.

스프링을 여러 번 학습했고, 현재 실무에서 사용하기도 하지만 기본 개념을 다시 다지자는 의미에서 기초 강의부터 따라가보자 한다.

개발자 관점에서 개념을 코드를 작성하면서 다뤄주고, 오래된 기술은 최대한 안쓰고.. 일단 첫 강의가 무료라서 우아한 형제들 김영한 강사님의 강의를 선택했다! 스프링 입문 - 코드로 배우는 스프링 부트, 웹 MVC, DB 접근 기술

프로젝트 생성하기

스프링 부트 스타터 사이트 에서 스프링 프로젝트를 생성한다. 위 사이트를 통해 손쉽게 스프링 프로젝트 생성이 가능하다.

• Project : Gradle
• Language : Java
• Spring Boot x.x.x
  • 뒤에 SNAPSHOT 등 아무것도 안붙은 버전 사용! ( 안정화된 버전임)
• Meta data
  • Group : 보통 기업 도메인 명을 적음
  • Artifact : 실제 빌드될 때 나오는 결과물 이름
• Packaging : Jar
• Java : 11
• Dependencies
  • Spring Web, Thymeleaf

라이브러리 살펴보기

• build.gradle 의 dependencies 의 라이브러리들을 가져온다.

• 기본적으로 mavenCentral() 이라는 원격 저장소에서 라이브러리를 가져온다.

    repositories {
       mavenCentral()
    }
  
    dependencies {
        implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
        implementation 'org.springframework.boot:spring-boot-starter-web'
        testImplementation 'org.springframework.boot:spring-boot-starter-test'
    }

• Maven, Gradle 같은 빌드 툴들은 Spring 라이브러리의 의존 관계를 알아서 관리해준다.

• 예를 들어 spring-boot-starter-web 라이브러리를 가져오면, spring-boot-starter-tomacat 등 의존하고 있는 필요한 라이브러리들을 자동으로 가져온다.

  • 참고 : spring-boot-starter 자체에 tomcat 서버가 내장되어 있다! 예전처럼 톰캣 서버 로컬에 깔고 할필요 없음 ㅎㅎ

• 로그 라이브러리

  • slf4j : 인터페이스
  • logback : 구현체
  • 위 두가지를 스프링에서는 표준 로그 라이브러리로 제공한다.

• Test 라이브러리

  • Junit 쓰며 요즘은 5버전 쓴다.

• spring-boot-starter-thymeleaf : 타임리프 템플릿 엔진(View)

• spring-boot-starter(공통) : 스프링 부트 + 스프링 코어 + 로깅

빌드

1. 스프링 프로젝트 내부의 .gradlew 파일을 이용한다.
2. 아래 커맨드를 사용하여 터미널에서 어플리케이션을 실행해볼 수 있다. (mac 기준)

> ./gradlew build
> cd build/libs
> java -jar {프로젝트 네임}-0.0.1-SNAPSHOT.jar

1. 참고 : ./gradlew clean build 시 build 폴더가 깔끔하게 삭제되고 새로 빌드된다.