[Spring] 스프링 기초 (1)

🏃🏻‍♂️ 기본훈련/Spring

[Spring] 스프링 기초 (1)

hades1 2024. 7. 22. 15:04

프로젝트 생성

Spring 프로젝트는 https://start.spring.io/ 에서 생성한다.

기본적으로 위와 같이 설정 후 Generate하면 프로젝트가 생성된다.

구성 항목들을 살펴보자. src에서 main과 test를 분리해놓았는데, 이는 test가 요즘 개발에서 중요하다는 것을 의미한다.

main에서 java를 제외한 모든 파일은 resources에 있다. gradle은 버전 설정 및 라이브러리를 가져오는 역할을 한다.

HelloSpringApplication은 Application을 실행시키는데 자체적으로 서버 기능을 할 수 있게 해주는 톰캣을 내장하고 있어서, 서버 역할을 가능하게 한다.

Setting - Build - Gradle에서 IntelliJ IDEA로 바꾸면, 자체적으로 실행하여 빨라진다.

build.Gradle에는 가져오는 라이브러리가 많지 않지만, External Libraries를 확인해보면, 라이브러리가 무지 많다. 이는 의존성 때문에 필요한 라이브러리까지 같이 가져온 결과이다.

의존 관계는 오른쪽 Gradle에서 확인할 수 있다. (*)은 중복되어서 제거되었다는 뜻이고, 더블 클릭하면 설치된 곳으로 이동한다.

View 환경 설정

View란 유저에게 보여지는 화면을 의미한다. 기본적으로 IP/static/resources/index.html로 접속된다.

Controller를 사용하면, IP/추가경로에 따라 템플릿을 다르게 제공할 수 있다.

package hades.hello_spring.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class HelloController {
    @GetMapping("hello")
    public String hello(Model model) {
        model.addAttribute("data", "hello!!");
        return "hello";
    }
}

컨트롤러 파일을 만들고, 클래스 위에 @Controller를 붙여야 한다. @GetMapping("hello")는 IP/hello로 GET Request가 들어왔을 때 처리를 의미하며, 모델이라는 것에 특성 이름이 data, 특성 값이 hello인 특성을 더해 return에 표기된 hello.html로 전달한다.

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Hello</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
</head>
<body>
<p th:text="'안녕하세요. ' + ${data}" >안녕하세요. 손님</p>
</body>
</html>

템플릿 엔진인 thymeleaf를 th로 사용한다. ${data}에는 전달된 특성 값이 들어가게 된다.

정리하면, 웹 브라우저가 IP/hello를 요청하면, 톰캣 서버에서 Controller에 전달하고, 모델을 templates/hello.html에 전달하여 웹 브라우저에 전달한다.

빌드하고 실행하기

cd PROJECT_FOLDER
gradlew
gradle build
cd lib
java -jar JAR

스프링 웹 개발 기초

정적 컨텐츠

항상 같은 View 파일을 제공한다.

컨트롤러에 먼저 있는지 확인 후, /resources/static에서 파일을 찾는다.

MVC와 템플릿 엔진

동적인 View 파일 제공, MVC = Model, View, Controller

View는 화면을 그리는 데, Controller는 비즈니스 로직을 위해, Model은 둘 사이를 연결하는데 집중시키기 위해 분리해놓았다.

@GetMapping("hello-mvc")
public String helloMvc(@RequestParam("name") String name, Model model){
    model.addAttribute("name", name);
    return "hello-mvc";
}

name으로 전달된 파라미터를 model에 전달하여 hello-mvc에 반영한다.

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Hello</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
</head>
<body>
<p th:text="'안녕하세요. ' + ${name} + '님 오늘도 파이팅!'" >hello empty</p>
</body>
</html>

text 내에서 +와 ''를 사용하여 구분을 잘 해야 한다.

API

데이터를 직접 넘기는 방식을 의미한다.

@GetMapping("hello-string")
@ResponseBody
public String helloString(@RequestParam String name) {
   return "hello " + name;
}

@ResponseBody는 HTTP의 Body에 return 값을 전달하겠다는 의미이다.

@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;
	public String getName(){
    	return name;
	}

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

객체 데이터를 바로 HTTP Body에 담아 Response로 제공한다.

웹 브라우저가 요청을 보내면, 톰캣 서버가 컨트롤러에 있는지 확인하고, 있으므로 ResponseBody가 있으면 HttpMessageConverter가 동작하는데, return value가 객체라면 JsonConverter를, String이라면 StringConverter가 작동되어 전달된다.

회원 관리 예제 - 백엔드

비즈니스 요구사항 정리

데이터: 회원ID, 이름
기능: 회원 등록, 조회
아직 데이터 저장소가 선정되지 않음(가상의 시나리오)

컨트롤러: 웹 MVC의 컨트롤러 역할
서비스: 핵심 비즈니스 로직 구현
리포지토리: 데이터베이스에 접근, 도메인 객체를 DB에 저장하고 관리
도메인: 비즈니스 도메인 객체, 예) 회원, 주문, 쿠폰 등등 주로 데이터베이스에 저장하고 관리됨

interface란 일종의 규제이다. interface를 구현한 클래스는 interface가 요구하는 것을 모두 구현해야 한다. MemoryMemberRepository는 DB 접근과 관련된 기능을 구현하고, MemberService는 그 기능들을 이용하여 추가 로직을 작성한다.

package hades.hello_spring.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;
    }
}

도메인은 활용하는 대상이라고 생각하면 될듯하다.

package hades.hello_spring.repository;

import hades.hello_spring.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();
}

interface인 MemberRepository에는 구현해야 하는 기능 함수를 명시한다.

package hades.hello_spring.repository;

import hades.hello_spring.domain.Member;

import java.util.*;

public class MemoryMemberRepository implements MemberRepository {
    private static Map<Long, Member> store = new HashMap<>();
    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());
        //return store.values().stream().toList();
    }
}

Memory에 저장할 예정이므로, Map을 생성한다. (HashMap 보다는 동시성을 위해 CurrentMap을 사용하는 분위기이다.)

Optional은 null이 와도 오류를 발생시키지 않게 한다. ofNullable은 null일 수도 있고, 아닐 수도 있는 객체를 생성한다.

stream은 집합체의 원소의 흐름이다.

List는 interface이고 ArrayList가 그것을 구현한 클래스이다.

package hades.hello_spring.repository;

import hades.hello_spring.domain.Member;
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;

public class MemoryMemberRepositoryTest {
    MemoryMemberRepository repository = new MemoryMemberRepository();

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

    @Test
    public void save(){
        Member member = new Member();
        member.setName("강호동");
        repository.save(member);
        Member result = repository.findById(member.getId()).get();
        // Assertions.assertEquals(result,  member);
        Assertions.assertThat(member).isEqualTo(result);
    }

    @Test
    public void findByName(){
        Member member1 = new Member();
        member1.setName("이승기");
        repository.save(member1);

        Member member2 = new Member();
        member2.setName("은지원");
        repository.save(member2);

        Member result = repository.findByName("은지원").get(); // 반환값이 Optional인 경우, get을 이용해 Optional을 깔 수 있음

        Assertions.assertThat(result).isEqualTo(member2);
    }

    @Test
    public void findAll(){
        Member member1 = new Member();
        member1.setName("이승기");
        repository.save(member1);

        Member member2 = new Member();
        member2.setName("은지원");
        repository.save(member2);

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

Test 패키지에 repository를 새로 만들고, 테스트를 위한 클래스를 생성한다.

@Test를 붙인다면, 한 클래스나 메소드 단위로 Test를 할 수 있다. 중요한 것은 클래스를 Test 할 때, 메소드의 순서가 랜덤이기 때문에 결과가 달라질 수 있다. 예를 들어, findAll이 실행되고, findByName이 실행되면, 이름은 같지만 참조가 다르므로, fail을 나타낸다. 따라서, 매번 메소드가 실행이 끝날 때마다 store를 비우기 위해 @AfterEach를 붙인 메소드를 생성한다.

Test를 구성하고, 구현하는 것을 Test-driven development = Tdd 라고 한다.

package hades.hello_spring.service;

import hades.hello_spring.domain.Member;
import hades.hello_spring.repository.MemberRepository;
import hades.hello_spring.repository.MemoryMemberRepository;

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

public class MemberService {
    private final MemberRepository memberRepository = new MemoryMemberRepository();

    public long join(Member member){
        validateDuplicateMember(member);
        memberRepository.save(member);
        return member.getId();
    }

    public void validateDuplicateMember(Member member){
        memberRepository.findByName(member.getName()).ifPresent(m->{
            throw new IllegalStateException("이미 존재하는 회원입니다.");
        });
    }

    public List<Member> findMembers(){
        return memberRepository.findAll();
    }

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

Repository가 DB와 관련된 작업만 한다면, Service는 실제 비즈니스 로직을 구현한다.

validateDuplicateMember에서 member.getName()의 결과는 Optional 객체이고, ifPresent는 Optional 안에 있는 것이 Member인지 null인지 확인하고, null이 아니라면 lambda 식을 실행한다.

어떤 클래스에서 Ctrl + Shift + T를 누르면, Test를 생성할 수 있다.

package hades.hello_spring.service;

import hades.hello_spring.domain.Member;
import hades.hello_spring.repository.MemoryMemberRepository;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;
class MemberServiceTest {
    MemberService memberService;
    MemoryMemberRepository memberRepository;
    // MemoryMemberRepository repository = new MemoryMemberRepository();

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

    @Test
    void 회원가입() {
        // given 조건 하에서
        Member member = new Member();
        member.setName("이수근");

        // when ~가 실행될 때
        long saveId = memberService.join(member);

        // then ~가 되어야 함
        Member findMember = memberService.findOne(saveId).get();
        org.assertj.core.api.Assertions.assertThat(member.getName()).isEqualTo(findMember.getName());
    }

    @Test
    void 중복_회원_예외() {
        // given
        Member member1 = new Member();
        member1.setName("이수근");

        Member member2 = new Member();
        member2.setName("이수근");

        // when
        memberService.join(member1);
        IllegalStateException e = assertThrows(IllegalStateException.class, () -> memberService.join(member2));
        org.assertj.core.api.Assertions.assertThat(e.getMessage()).isEqualTo("이미 존재하는 회원입니다.");

        // then
    }

    @Test
    void findMembers() {
    }

    @Test
    void findOne() {
    }
}

MemoryMemberRepository에서 store가 static으로 선언되어 있어서 이 경우에는 괜찮지만, static으로 생성되지 않은 경우에는 new MemoryMemberRepository()을 하게 되면 다른 store를 가르킬 수 있다. 따라서, MemoryMemberRepository를 생성하고, 그 MemoryMemberRepository를 MemoryService에 전달하여 같은 store를 가지게 하는 것이 좋다.

스프링 빈과 의존관계

빈(Bean)은 스프링 컨테이너에 의해 관리되는 재사용 가능한 소프트웨어 컴포넌트이다.

즉, 스프링 컨테이너가 관리하는 자바 객체를 뜻하며, 하나 이상의 빈(Bean)을 관리한다.

빈은 인스턴스화된 객체를 의미하며, 스프링 컨테이너에 등록된 객체를 스프링 빈이라고 한다. 스프링 빈은 기본적으로 유일하게 하나만 등록해서 공유한다. memberService와 orderService가 memberRepository를 주입받는다면 그것은 같은 것이라는 의미이다.

스프링 빈을 등록하는 방법

1. 컴포넌트 스캔을 하여 스프링 빈을 등록하고, 자동 의존 관계로 이용할 수 있게 한다. 스프링 빈으로 등록하기 위해서 클래스에 @Controller, @Service, @Repository를 추가하고, 주입받으려면 @Autowired를 이용하면 된다.

컴포넌트 스캔의 기본적인 범위는 Application이 있는 상위 패키지라는 것에 유의해야 한다.

2. 직접 등록

package hades.hello_spring;

import hades.hello_spring.repository.MemberRepository;
import hades.hello_spring.repository.MemoryMemberRepository;
import hades.hello_spring.service.MemberService;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class SpringConfig {

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

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

회원 관리 - 웹 MVC

컨트롤러, 템플릿 생성이라 추가하지 않았다.

스프링 DB 접근 기술

h2 데이터베이스를 사용하기 위해서 https://www.h2database.com 에서 설치한다.

/h2/bin/에서 h2.bat을 실행하면, 데이터베이스 페이지로 접속된다. 오류가 발생하면 IP 부분을 localhost로 바꿔준다. 또한, cmd 창은 끄지 말아야 한다.

JPA를 사용하기 위해 build.grandle에 다음 코드를 추가한다.

dependencies {
implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
implementation 'org.springframework.boot:spring-boot-starter-web'
// implementation 'org.springframework.boot:spring-boot-starter-jdbc'
implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
runtimeOnly 'com.h2database:h2'
testImplementation('org.springframework.boot:spring-boot-starter-test') {
exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'
}
}

package hades.hello_spring;

import hades.hello_spring.repository.JpaMemberRepository;
import hades.hello_spring.repository.MemberRepository;
import hades.hello_spring.repository.MemoryMemberRepository;
import hades.hello_spring.service.MemberService;
import jakarta.persistence.EntityManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.swing.*;

@Configuration
public class SpringConfig {

    private final EntityManager em;

    public SpringConfig(EntityManager em) {
        this.em = em;
    }

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

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

}

SpringConfig에서 EntityManager를 설정해야 한다. 자동으로 삽입된다. memberRepository를 JpaMemberRepository로 바꾸고, EntityManager를 전달한다.

package hades.hello_spring.repository;

import hades.hello_spring.domain.Member;
import jakarta.persistence.EntityManager;

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


public class JpaMemberRepository implements MemberRepository{

    private final EntityManager em;

    public JpaMemberRepository(EntityManager em) {
        this.em = em;
    }

    @Override
    public Member save(Member member) {
        em.persist(member);
        return member;
    }

    @Override
    public Optional<Member> findById(long id) {
        Member member = em.find(Member.class, id);
        return Optional.ofNullable(member);
    }

    @Override
    public Optional<Member> findByName(String name) {
        List<Member> result = em.createQuery("select m from Member m where m.name = :name", Member.class)
                .setParameter("name", name)
                .getResultList();
        return result.stream().findAny();
    }

    @Override
    public List<Member> findAll() {
        return em.createQuery("select m form Member as m", Member.class).getResultList();
    }
}

package hades.hello_spring.repository;

import hades.hello_spring.domain.Member;
import org.springframework.data.jpa.repository.JpaRepository;

import java.util.Optional;

public interface SpringDataJpaMemberRepository extends JpaRepository<Member, Long>, MemberRepository {
    @Override
    Optional<Member> findByName(String name);
}

JpaRepository를 상속받으면, 자동으로 스프링 빈으로 구현된다. 또한 알아서 JPQL 쿼리를 구현한다.

스프링 데이터 JPA 제공 기능

인터페이스를 통한 기본적인 CRUD
findByName() , findByEmail() 처럼 메서드 이름 만으로 조회 기능 제공
페이징 기능 자동 제공

AOP

시간을 측정하기 위해서는 아래와 같은 코드로 작성해야 한다.

public Long join(Member member) {
	long start = System.currentTimeMillis();
	try {
		validateDuplicateMember(member); //중복 회원 검증
		memberRepository.save(member);
		return member.getId();
	} finally {
		long finish = System.currentTimeMillis();
		long timeMs = finish - start;
		System.out.println("join " + timeMs + "ms");
	}
}

문제는...

회원가입, 회원 조회에 시간을 측정하는 기능은 핵심 관심 사항이 아니다.
시간을 측정하는 로직은 공통 관심 사항이다.
시간을 측정하는 로직과 핵심 비즈니스의 로직이 섞여서 유지보수가 어렵다.
시간을 측정하는 로직을 별도의 공통 로직으로 만들기 매우 어렵다.
시간을 측정하는 로직을 변경할 때 모든 로직을 찾아가면서 변경해야 한다.

AOP는 공통 관심 사항과 핵심 관심 사항을 분리하고, 공통 관심 사항의 적용 범위를 지정하여 위 문제를 해결한다.

package hades.hello_spring.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;

@Aspect
public class TimeTraceAop {

    @Around("execution(* hades.hellospring..*(..))")
    public Object execute(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        System.out.println("START:" + joinPoint.toString());
        try{
            return joinPoint.proceed();
        } finally {
            long finish = System.currentTimeMillis();
            long timeMs = finish - start;
            System.out.println("END:" + joinPoint.toString());
        }

    }
}

이로 인해 얻을 수 있는 결과는 다음과 같다.

- 회원가입, 회원 조회등 핵심 관심사항과 시간을 측정하는 공통 관심 사항을 분리한다.
- 시간을 측정하는 로직을 별도의 공통 로직으로 만들었다.
- 핵심 관심 사항을 깔끔하게 유지할 수 있다.
- 변경이 필요하면 이 로직만 변경하면 된다.
- 원하는 적용 대상을 선택할 수 있다.