AOP(Aspect-Oriented Programming)는 공통 관심 사항(Cross-Cutting Concerns)을 모듈화하여 관리한다.
회원가입, 회원 조회에 시간을 측정하는 기능은 핵심 관심 사항(Core Concerns)가 아니고, 시간을 측정하는 로직은 공통 관심 사항이다. 하지만 각 기능에 시간을 측정하는 기능을 넣을 경우 비즈니스 로직이 섞여 유지보수가 어렵고, 시간을 측정하는 기능에 수정이 발생할 때 모든 부분을 수정해야해서 불편하다.
TimeTraceAop를 작성한다. @Aspect 어노테이션으로 AOP임을 나타내고, @Around 어노테이션으로 적용될 클래스를 명시한다. 스프링 빈에 올리기 위해 @Component 어노테이션을 사용한다. 이렇게 핵심 관심 사항과 공통 관심 사항을 분리할 수 있다.
AOP 적용 전에는 memberController가 memberService를 호출했다면, AOP 적용 후에는 memberController가 프록시 memberService(복제 된)를 호출하고, 프록시 memberService가 joinPoint.proceed() 메소드를 통해 실제 memberService를 호출하게 된다.
AOP를 마지막으로 스프링 입문 강의가 끝났다. 이번에 한 AOP도 그렇고 자세하게 공부할 것들이 많다...
~/test로 연결 하면 Windows 기준 USERPROFILE 경로에 test.mv.db가 생긴다.
/* DROP TABLE IF EXISTS MEMBER CASCADE; */
CREATE TABLE MEMBER
(
ID BIGINT GENERATED BY DEFAULT AS IDENTITY,
NAME VARCHAR(255),
PRIMARY KEY (ID)
);
INSERT INTO MEMBER(NAME) VALUES('member1');
INSERT INTO MEMBER(NAME) VALUES('member2');
INSERT INTO MEMBER(NAME) VALUES(666, '666member');
member 테이블 생성하고 데이터를 삽입한다. ID는 BIGINT 타입으로 지정하고, 값을 입력하지 않았을 때 GENERATED BY DEFAULT AS IDENTITY가 자동으로 값을 입력해준다. NAME은 VARCHAR 타입으로 255자까지 가변적으로 입력가능한 문자열이다. PK로 ID를 지정하여 고유한 값을 갖게 된다.
좌측 메뉴에서 테이블명을 선택하면 자동으로 Select문이 생성되어 쉽게 조회 할 수 있다. 방금 삽입한 3개의 member가 조회된다.
순수 JDBC
이제는 사용하지 않는 방식이라고 넘어갔지만 코드 작성해서 실행해보았다.
@Configuration
public class SpringConfig {
@Autowired
private final DataSource dataSource;
public SpringConfig(DataSource dataSource) {
this.dataSource = dataSource;
}
@Bean
public MemberService memberService() {
return new MemberService(memberRepository());
}
@Bean
public MemberRepository memberRepository() {
// return new MemoryMemberRepository();
return new JdbcMemberRepository(dataSource);
}
}
SpringConfig에 DataSource를 추가해주고, memberRepository에서 작성한 JdbcMemberRepository로 변경한다. DataSource는 데이터베이스와의 커넥션을 획득할 때 사용하는 객체로, 스프링 부트에서는 정보(application.properties)를 바탕으로 DataSource를 생성하고 스프링 빈으로 만들어 두기 때문에 의존성 주입(DI)을 받을 수 있다.
스프링 통합 테스트
MemberServiceIntegrationTest
package hello.hello_spring.service;
import hello.hello_spring.domain.Member;
import hello.hello_spring.repository.MemberRepository;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.transaction.annotation.Transactional;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
@SpringBootTest
@Transactional
public class MemberServiceIntegrationTest {
@Autowired MemberService memberService;
@Autowired MemberRepository memberRepository;
@Test
public void 회원가입() throws Exception {
//Given
Member member = new Member();
member.setName("hello");
//When
Long saveId = memberService.join(member);
//Then
Member findMember = memberRepository.findById(saveId).get();
assertEquals(member.getName(), findMember.getName());
}
@Test
public void 중복_회원_예외() throws Exception {
//Given
Member member1 = new Member();
member1.setName("spring");
Member member2 = new Member();
member2.setName("spring");
//When
memberService.join(member1);
IllegalStateException e = assertThrows(IllegalStateException.class,
() -> memberService.join(member2));//예외가 발생해야 한다.
assertThat(e.getMessage()).isEqualTo("이미 존재하는 회원입니다.");
}
}
이전에 했던 단위 테스트 말고 통합 테스트를 위한 MemberServiceIntegrationTest 클래스 파일을 작성한다. @SpringBootTest 어노테이션으로 스프링 컨테이너를 테스트와 함께 실행하도록 하며, @Transactional 어노테이션으로 테스트 트랜잭션 시작 후 종료 시에 전부 롤백하도록 한다. @Transactional 어노테이션이 없으면 데이터베이스 PK 문제 발생 시 테스트 케이스를 계속 바꿔줘야할 수 있다.
스프링 JdbcTemplate
스프링 JdbcTemplate는 JDBC 코드의 반복적인 부분을 줄여준다.
JdbcTemplateMemberRepository
//import 생략
public class JdbcTemplateMemberRepository implements MemberRepository {
private final JdbcTemplate jdbcTemplate;
@Autowired
public JdbcTemplateMemberRepository(DataSource dataSource) {
jdbcTemplate = new JdbcTemplate(dataSource);
}
@Override
public Member save(Member member) {
SimpleJdbcInsert jdbcInsert = new SimpleJdbcInsert(jdbcTemplate);
jdbcInsert.withTableName("member").usingGeneratedKeyColumns("id");
Map<String, Object> parameters = new HashMap<>();
parameters.put("name", member.getName());
Number key = jdbcInsert.executeAndReturnKey(new MapSqlParameterSource(parameters));
member.setId(key.longValue());
return member;
}
@Override
public Optional<Member> findById(Long id) {
List<Member> result = jdbcTemplate.query("select * from member where id = ?", memberRowMapper(), id);
return result.stream().findAny();
}
@Override
public List<Member> findAll() {
return jdbcTemplate.query("select * from member", memberRowMapper());
}
@Override
public Optional<Member> findByName(String name) {
List<Member> result = jdbcTemplate.query("select * from member where name = ?", memberRowMapper(), name);
return result.stream().findAny();
}
private RowMapper<Member> memberRowMapper() {
return (rs, rowNum) -> {
Member member = new Member();
member.setId(rs.getLong("id"));
member.setName(rs.getString("name"));
return member;
};
}
}
이후에 Spring Config에서 JdbcTemplateMemberRepository를 사용하도록 수정해준다.
//생략
@Bean
public MemberRepository memberRepository() {
// return new MemoryMemberRepository();
// return new JdbcMemberRepository(dataSource);
return new JdbcTemplateMemberRepository(dataSource);
}
JPA
JPA는 자바에서 ORM(Object-Relational Mapping, 객체-관계 매핑)을 위한 표준 인터페이스로, 자바 객체와 관계형 데이터베이스 간의 매핑을 쉽게 하여 개발자가 SQL 쿼리를 작성하지 않아도 된다. (인터페이스이므로 실제 구현이 필요하다. 대표적으로 Hibernate, EclipseLink, OpenJPA 등이 있다.)
주요 기능으로는 객체 중심의 개발(쿼리보다 자바 객체에 집중하여 개발 생산성 향상과 유지보수 용이), CRUD 작업 자동화, ORM 기능(자바 객체와 데이터베이스 테이블 간의 매핑 제공으로 패러다임 불일치 해결)이 있고, 주요 구성 요소로는 Entity(데이터베이스 테이블과 매핑되는 자바 클래스, @Entity 어노테이션), Entity Manager(Entity의 생명주기를 관리하는 인터페이스로 CRUD 작업 수행), Persistent Context(영속성 컨텍스트, Entity Manager가 관리하는 Entity 인스턴스의 집합으로 데이터베이스와의 동기화를 도움)가 있다.
그리고 application.properties에 옵션을 추가해준다. show-sql은 jpa가 생성한 쿼리를 보여주고, ddl-auto는 jpa가 자동으로 테이블을 생성할지 여부이다. 이미 생성된 테이블을 사용하고 있어서 none으로 설정했지만, create로 하면 테이블을 생성해준다.
//생략
@Entity
public class Member {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
Member 도메인을 Entity로 사용하기 위해 @Entity 어노테이션을 설정해주고, @Id 어노테이션으로 PK를 지정, @GeneratedValue 어노테이션으로 값을 자동으로 생성해준다.
JpaMemberRepository
package hello.hello_spring.repository;
import hello.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;
}
public Member save(Member member) {
em.persist(member);
return member;
}
public Optional<Member> findById(Long id) {
Member member = em.find(Member.class, id);
return Optional.ofNullable(member);
}
public List<Member> findAll() {
return em.createQuery("select m from Member m", Member.class)
.getResultList();
}
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();
}
}
JpaMemberRepository를 작성한다. DataSource를 받아오는게 아니라 EntityManager를 불러와서 사용한다.
//생략
@Transactional
public class MemberService {
`MemberService'에 @Transactional 어노테이션을 달아준다. jpa의 모든 쿼리는 트랙잭션 내에서 실행되어야 한다.
//생략
@Configuration
public class SpringConfig {
private final DataSource dataSource;
private final EntityManager em;
public SpringConfig(DataSource dataSource, EntityManager em) {
this.dataSource = dataSource;
this.em = em;
}
@Bean
public MemberService memberService() {
return new MemberService(memberRepository());
}
@Bean
public MemberRepository memberRepository() {
// return new MemoryMemberRepository();
// return new JdbcMemberRepository(dataSource);
// return new JdbcTemplateMemberRepository(dataSource);
return new JpaMemberRepository(em);
}
}
SpringConfig에서 JpaMemberRepository를 사용하도록 변경한다. EntityManager를 추가한다. 이후 테스트를 돌리거나 실행하면 정상적으로 완료된다. jpa는 이런 쿼리를 생성했다.
SpringDataJpaMemberRepository를 작성한다. 클래스가 아닌 인터페이스로 작성하고, JpaRepository를 상속하게 되면 스프링 실행 시 자동으로 스프링 빈에 등록되어 사용할 수 있게된다.
//생략
@Configuration
public class SpringConfig {
private final MemberRepository memberRepository;
public SpringConfig(MemberRepository memberRepository) {
this.memberRepository = memberRepository;
}
@Bean
public MemberService memberService() {
return new MemberService(memberRepository);
}
}
SpringConfig에서 MemberRepository만 의존성 주입 받으면 된다.
스프링 데이터 JPA는 JPA 기반으로 구축되었고, 기본적인 CRUD 기능도 대부분 제공한다. findByID, findByAll 등등. 우선 강의에 있어 스프링 데이터 JPA를 사용해보았으나, 우선 JPA에 대한 이해도를 높일 필요가 있어 보이고, 결국 모든 쿼리를 JPA로 처리할 수 없어서 네이티브 쿼리나 JdbcTemplate과의 조합 등의 사용도 고려해야한다.
빌드하고 localhost:8080 접속하면 위 화면이 나온다. 지난 번에 static/index.html 파일을 만들어서 Controller에 루트 컨텍스트("/")가 없으면 해당 파일을 보여주도록 했으나, 이번에는 Controller에 루트 컨텍스트를 지정하여 template/home.html 파일을 보여준다. 두 버튼에 대해서는 아직 화면이 없어서 오류 화면으로 넘어간다.
등록 화면 추가
MemberController.java
...
@GetMapping("members/new")
public String createForm() {
return "members/createMemberForm";
}
@PostMapping("members/new")
public String create(MemberForm form) {
Member member = new Member();
member.setName(form.getName());
memberService.join(member);
return "redirect:/";
}
...
...
public class MemberForm {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
홈 화면에서 회원 가입을 클릭하면 방금 만든 등록 화면(template/createMemberForm.html)으로 이동한다. 이동하면 위와 같이 이름을 입력하고 등록할 수 있는 버튼이 생긴다. 여기서 form을 활용하게 되는데, form 태그에 명시한대로 등록(submit) 버튼을 클릭하면 POST 메소드를 사용해 /members/new를 호출한다. MemberController에서 @PostMapping 어노테이션을 달고 있는 메소드를 찾고, 실행한다. MemberForm에 private로 생성한 name에 input 태그에 명시한 name 프로퍼티의 값이 name으로 같을 때 해당 MemberForm 데이터로 들어가고, 이 name으로 member를 생성, 홈 화면으로 돌아간다.
조회 화면 추가
MemberController.java
...
@GetMapping("/members")
public String list(Model model) {
List<Member> members = memberService.findMembers();
model.addAttribute("members", members);
return "members/memberList";
}
등록 화면에서 회원을 등록하면 위 처럼 id와 name이 나온다. 조회 화면에 들어오면 findMembers() 메소드로 회원 목록을 조회하고, List를 Model에 추가하여 memberList.html로 전달한다. 그럼 thymeleaf가 th:each로 members List를 순회하며 member의 id와 name을 반복하여 출력하는 형태이다.
@Controller
public class MemberController {
private final MemberService memberService;
@Autowired
public MemberController(MemberService memberService) {
this.memberService = memberService;
}
}
MemberController 파일을 작성하고 잘 동작하는지 실행해보면 Parameter 0 of constructor in hello.hello_spring.controller.MemberController required a bean of type 'hello.hello_spring.service.MemberService' that could not be found.라는 오류가 발생한다. @Controller 어노테이션을 달고 있는 MemberController는 스프링 컨테이너가 시작 될 때 객체를 생성하지만, MemberService는 생성하지 않아서 발생하는 오류이다. 스프링 빈에 등록한다고 하는데, 스프링 빈에 등록하는 방법은 2가지가 있다.
컴포넌트 스캔과 자동 의존관계 설정
자바 코드로 직접 스프링 빈 등록하기
@Service
public class MemberService {
...
}
MemberService 앞에 @Service 어노테이션을 달면 스프링 빈에 등록된다. MemoryMemberRepository도 마찬가지고 @Repository 어노테이션을 등록하면 된다. 원래는 @Component 어노테이션이 스캔 대상이지만, @Controller, @Service, @Repository 어노테이션 안에도 @Component 어노테이션을 포함하고 있어서 스캔 대상(스프링 빈에 등록)에 포함된다.
@Service
public class MemberService {
private final MemberRepository memberRepository;
@Autowired
public MemberService(MemberRepository memberRepository) {
this.memberRepository = memberRepository;
}
...
}
MemberService 생성자에 @Autowired 어노테이션을 달면 객체 생성 시점에 스프링 컨테이너가 스프링 빈에서 내용을 찾아 의존성을 주입한다. 참고로 스프링은 스프링 컨테이너에 스프링 빈을 등록할 때, 기본으로 싱글톤으로 등록한다. 따라서 같은 스프링 빈이면 모두 같은 인스턴스이다. 설정을 통해 싱글톤이 아니게 할 수 있으나, 특별한 경우를 제외 대부분 싱글톤을 사용한다.
싱글톤 패턴
클래스의 인스턴스를 하나만 생성하고, 이를 전역으로 공유하여 사용하는 디자인 패턴
특징 : 인스턴스의 유일성 보장, 전역 접근 가능, 메모리 효율성(장점과 유사)
단점 : 높은 결합도, 멀티스레드 문제, 테스트 어려움
스프링 빈
스프링 컨테이너에 의해 관리되는 Java 객체를 의미한다. 일반적인 Java 객체와 동일하지만, 스프링 컨테이너가 객체의 생성, 초기화, 의존성 주입, 소멸 등 생명 주기를 관리한다는 점에서 차이가 있다.
자바 코드로 직접 스프링 빈 등록하기
MemberService와 MemoryMemberRepository에 등록한 @Service, @Repository, @Autowired 어노테이션 제거 후 SpringConfig 클래스 작성한다.
@Configuration
public class SpringConfig {
@Bean
public MemberService memberService() {
return new MemberService(memberRepository());
}
@Bean
public MemberRepository memberRepository() {
return new MemoryMemberRepository();
}
}
@Configuration 어노테이션으로 시작하고, 각 스프링 빈에 추가할 객체에 대해서 @Bean 어노테이션을 달고 작성해준다. 이전에 어떤 형태로 데이터를 저장할지 정해진게 없어 Repository는 인터페이스 형태로 추가하였고, 현재는 MemoryMemberRepository를 사용하고 있다. 나중에 DB나 다른 형태로 변경 될 때 SpringConfig에서 내용만 바꿔주면 된다.
데이터는 회원ID와 이름, 기능은 회원 등록과 조회만 있고 아직 DB가 선정되지 않은 가상의 시나리오이다.
일반적인 웹 애플리케이션의 계층 구조이다.
Controller : 웹 MVC의 컨트롤러 역할을 한다.
Service : 핵심 비즈니스 로직을 구현한다.
Repository : DB에 접근하며, 도메인 객체를 DB에 저장하고 관리한다.
Domain : 비즈니스 도메인 객체(예 : 회원, 주문, 쿠폰 등)로 주로 DB에 저장하고 관리한다.
클래스 의존 관계이다. 아직 DB가 선정되지 않아 인터페이스로 구현 클래스를 변경할 수 있도록 설계하며, DB는 RDB, NoSQL 등 다양한 저장소를 고민 중인 상황이다. 개발 진행을 위해 초기 개발 단계에서는 구현체로 가벼운 메모리 기반의 데이터 저장소를 사용한다. 여기서 인터페이스는 '클래스가 따라야 할 설계도' 역할로 다음과 같은 특징을 가진다.
구성 요소
추상 메소드 : 인터페이스에 선언된 메소드는 기본적으로 abstract이며, 구현 클래스에서 반드시 구현해야 한다.
상수 : 인터페이스에 선언된 변수는 자동으로 public static final이 된다.
기타 메소드 : Java 8 부터 default 메소드와 static 메소드를 포함할 수 있다.
다중 상속 지원 : 클래스는 하나의 부모 클래스만 상속할 수 있지만, 인터페이는 여러개를 구현할 수 있다.
객체 생성 불가 : 인터페이스 자체로는 객체를 생성할 수 없으며, 이를 구현한 클래스만 인스턴스화가 가능하다.
유연한 참조 : 인터페이스 타입의 참조변수를 통해 구현 객체를 다룰 수 있어, 코드 변경 없이 다양한 객체를 교체할 수 있다.
회원 도메인과 리포지토리 만들기
Member.java
package hello.hello_spring.domain;
public class Member {
private Long id;
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
}
MemberRepository.java
package hello.hello_spring.repository;
import hello.hello_spring.domain.Member;
import java.util.List;
import java.util.Optional;
public interface MemberRepository {
//저장
Member save(Member member);
//Id로 찾기
Optional<Member> findById(Long id);
//이름으로 찾기
Optional<Member> findByName(String name);
//모든 회원 찾기
List<Member> findAll();
}
MemoryMemberRepository.java
package hello.hello_spring.repository;
import hello.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());
}
}
회원 리포지토리 테스트 케이스 작성
MemoryMemberRepositoryTest.java
public class MemoryMemberRepositoryTest {
MemoryMemberRepository repository = new MemoryMemberRepository();
@AfterEach
public void afterEach() {
repository.clearStore();
}
@Test
public void save() {
Member member = new Member();
member.setName("spring");
repository.save(member);
Member result = repository.findById(member.getId()).get();
assertThat(member).isEqualTo(result);
}
@Test
public void findByName() {
Member member1 = new Member();
member1.setName("spring1");
repository.save(member1);
Member member2 = new Member();
member2.setName("spring1");
repository.save(member2);
Member result = repository.findByName("spring1").get();
assertThat(result).isEqualTo(member1);
}
@Test
public void findAll() {
Member member1 = new Member();
member1.setName("spring1");
repository.save(member1);
Member member2 = new Member();
member2.setName("spring1");
repository.save(member2);
List<Member> result = repository.findAll();
assertThat(result.size()).isEqualTo(2);
}
}
JUnit을 활용한 테스트이다. main 디렉토리 아래가 아닌 test 디렉토리 아래에 테스트를 위한 클래스를 작성하면 된다. 테스트 메소드가 여러개 있을 때 코드에 작성된 대로 순차적으로 실행되지 않기 때문에 변수 등에 저장된 값에 의해 의도치 않은 실패가 발생할 수 있다. 이를 방지하기 위해 @AfterEach 어노테이션을 통해 각 테스트 메소드가 종료되면 실행하는 메소드를 작성하면 된다. 여기서는 HashMap을 clear한다.
테스트는 언제나 중요하며, 개발 → 테스트가 아닌 반대의 경우도 있다. 이를 테스트 주도 개발(Test-Driven Development, TDD)라고 한다. TDD는 테스트 코드를 먼저 작성한 후 이를 통과하는 실제 코드를 구현하는 방식이다.코드 품질 향상, 유지보수 용이성 등의 장점이 있으면서 초기 시간 투자 증가, 학습 곡선 등의 단점도 있다.
회원 서비스 개발
MemberService.java
public class MemberService {
private final MemberRepository memberRepository = new MemoryMemberRepository();
//회원 가입
public Long join(Member member) {
//중복 회원 불가
validateDuplicateMember(member);
memberRepository.save(member);
return member.getId();
}
private 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);
}
}
서비스는 실제 비즈니스 로직을 구현한다.
회원 서비스 테스트
클래스에 대해 테스트 클래스를 쉽게 생성하는 방법은 윈도우 기준 Ctrl + Shift + T 단축키를 누르면 된다.
MemberService.java
class MemberServiceTest {
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
Member findMember = memberService.findOne(saveId).get();
assertThat(member.getName()).isEqualTo(findMember.getName());
}
@Test
public void 중복회원가입() {
//given
Member member1 = new Member();
member1.setName("spring");
Member member2 = new Member();
member2.setName("spring");
//when
memberService.join(member1);
IllegalStateException e = Assertions.assertThrows(IllegalStateException.class, () -> memberService.join(member2));
assertThat(e.getMessage()).isEqualTo("이미 존재하는 회원입니다.");
/*
try {
memberService.join(member2);
fail();
} catch (IllegalStateException e) {
assertThat(e.getMessage()).isEqualTo("이미 존재하는 회원입니다.");
}
*/
}
@Test
void 전체회원조회() {
Member member1 = new Member();
member1.setName("spring1");
memberRepository.save(member1);
Member member2 = new Member();
member2.setName("spring1");
memberRepository.save(member2);
List<Member> result = memberRepository.findAll();
assertThat(result.size()).isEqualTo(2);
}
@Test
void 회원조회() {
Member member1 = new Member();
member1.setName("spring1");
memberRepository.save(member1);
Member result = memberRepository.findByName("spring1").get();
assertThat(result).isEqualTo(member1);
}
}
테스트를 작성할 때는 given(어떤 환경에서), when(어떤 조건이 발생했을때), then(어떤 결과가 나오는지)의 3단계로 작성하면 쉽다. @BeforeEach 어노테이션으로 테스트 시에도 같은 MemberRepository를 사용하기 위해 의존성 주입 형태로 변경했다. 의존성 주입(Dependency Injection, DI)은 객체 간의 의존 관계를 외부에서 주입하여 관리하는 설계 패턴이다. 의존성 주입에 대해서는 다음에 자세히 알아보겠다.
View는 보여지는 역할이며, Model이나 Controller는 내부에서 비즈니스 로직을 처리하는 역할이다.
@GetMapping("hello-mvc")
public String helloMvc(@RequestParam("name") String name, Model model) {
model.addAttribute("name", name);
return "hello-template";
}
/hello-mvc?name=hong을 호출하면 Controller에서 hello-mvc와 매핑된 걸 찾고, 입력 받은 name 파라미터를 받아서 hello-template로 View에전달하면, View는 ${name}을 파라미터로 치환한다. 여기서 템플릿 엔진인 Thymeleaf가 템플릿 양식과 데이터를 결합한 최종 HTML을 생성해서 클라이언트에 전달하는 방식이다.
API
@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;
}
}
@ResponseBody 어노테이션을 사용하면 위 템플릿 엔진과 다르게 HTTP Body에 JSON 형식의 데이터가 그대로 전달된다. /hello-api?name=hong을 호출하면 Controller에서 hello-api와 매핑된 걸 찾고, @ResponseBody를 확인하면 viewResolver 대신 HttpMessageConverter가 동작하면서 JSON 형식으로 전달하는 것이다.
