반응형
반응형

 

 

"김영한 스프링 핵심 원리 기본편" 내용을 기반으로 작성한 내용입니다.

 

스프링 핵심 원리 - 기본편 강의 | 김영한 - 인프런

김영한 | 스프링 입문자가 예제를 만들어가면서 스프링의 핵심 원리를 이해하고, 스프링 기본기를 확실히 다질 수 있습니다., 스프링 핵심 원리를 이해하고, 성장하는 백엔드 개발자가 되어보

www.inflearn.com

 

📝Spring으로 전환하기

@Configuration
public class AppConfig {
  @Bean
  public MemberService memberService() {
    return new MemberServiceImpl(memberRepository());
  }

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

}
  • @Configuration
    • 해당 설정을 Spring Container로 사용하겠다는 의미이다.
  • @Bean
    • Spring Container에 등록하겠다는 의미로 해당 정보를 다른 곳에서 꺼내서 쓸 수 있게 도와준다. 기본적으로 메서드의 명을 스프링 빈의 이름으로 사용한다. (물론 변경 가능)
    • 주의점으로 Bean이름이 겹치면 안 된다. (유일해야 함)

 

public class MemberApp {
  public static void main(String[] args) {

    /** AppConfig설정이 들어간 Spring Container를 사용하겠다 **/
    ApplicationContext applicationContext = new
        AnnotationConfigApplicationContext(AppConfig.class);

    /** Spring Container에 등록된 Bean에서 MemberService를 가져오겠다. **/
    MemberService memberService =
        applicationContext.getBean("memberService", MemberService.class);


    /** 회원가입 **/
    Member member = new Member(1L, "memberA", Grade.VIP);
    memberService.join(member);

    /** 회원찾기 **/
    Member findMember = memberService.findMember(1L);

    System.out.println("new member = " + member.getName());
    System.out.println("find Member = " + findMember.getName());
  }
}

 

📝Spring Bean 조회해보기

부모타입으로 조회하면 자식 타입도 함께 조회한다. 그래서 Object 타입으로 조회하면 모든 스프링 빈을 조회하게 된다.

 

public class ApplicationContextInfoTest {

  AnnotationConfigApplicationContext ac = new
      AnnotationConfigApplicationContext(AppConfig.class);

  @Test
  @DisplayName("모든 빈 출력하기")
  void findAllBean() {
    String[] beanDefinitionNames = ac.getBeanDefinitionNames();
    for (String beanDefinitionName : beanDefinitionNames) {
      Object bean = ac.getBean(beanDefinitionName);
      System.out.println("name=" + beanDefinitionName + " object=" +
          bean);
    }
    // name=org.springframework.context.annotation.internalCommonAnnotationProcessor object=org.springframework.context.annotation.CommonAnnotationBeanPostProcessor@602e0143
    // name=org.springframework.context.event.internalEventListenerProcessor object=org.springframework.context.event.EventListenerMethodProcessor@2c07545f
    // name=org.springframework.context.event.internalEventListenerFactory object=org.springframework.context.event.DefaultEventListenerFactory@e57b96d
    // name=appConfig object=com.spring.core.AppConfig$$SpringCGLIB$$0@32c726ee
    // name=memberService object=com.spring.core.member.MemberServiceImpl@22f31dec
    // name=memberRepository object=com.spring.core.member.MemoryMemberRepository@34c01041
  }

  @Test
  @DisplayName("애플리케이션 빈 출력하기")
  void findApplicationBean() {
    String[] beanDefinitionNames = ac.getBeanDefinitionNames();
    for (String beanDefinitionName : beanDefinitionNames) {
      BeanDefinition beanDefinition =
          ac.getBeanDefinition(beanDefinitionName);
      if (beanDefinition.getRole() == BeanDefinition.ROLE_APPLICATION) {
        Object bean = ac.getBean(beanDefinitionName);
        System.out.println("name=" + beanDefinitionName + " object=" +
            bean);
        // name=appConfig object=com.spring.core.AppConfig$$SpringCGLIB$$0@38234a38
        // name=memberService object=com.spring.core.member.MemberServiceImpl@63fbfaeb
        // name=memberRepository object=com.spring.core.member.MemoryMemberRepository@602e0143
      }
    }
  }

  @Test
  @DisplayName("빈 이름으로 조회")
  void findBeanByName() {
    MemberService memberService = ac.getBean("memberService",
        MemberService.class);
    assertThat(memberService).isInstanceOf(MemberServiceImpl.class);
  }

  @Test
  @DisplayName("이름 없이 타입만으로 조회")
  void findBeanByType() {
    MemberService memberService = ac.getBean(MemberService.class);
    assertThat(memberService).isInstanceOf(MemberServiceImpl.class);
  }

  @Test
  @DisplayName("구체 타입으로 조회")
  void findBeanByName2() {
    MemberServiceImpl memberService = ac.getBean("memberService",
        MemberServiceImpl.class);
    assertThat(memberService).isInstanceOf(MemberServiceImpl.class);
  }
  
  @Test
  @DisplayName("특정 타입을 모두 조회하기")
  void findAllBeanByType() {
    Map<String, MemberRepository> beansOfType =
        ac.getBeansOfType(MemberRepository.class);
    for (String key : beansOfType.keySet()) {
      System.out.println("key = " + key + " value = " +
          beansOfType.get(key));
    }
    System.out.println("beansOfType = " + beansOfType);
    assertThat(beansOfType.size()).isEqualTo(2);
  }
  
  @Test
  @DisplayName("부모 타입으로 모두 조회하기 - Object")
  void findAllBeanByObjectType() {
    Map<String, Object> beansOfType = ac.getBeansOfType(Object.class);
    for (String key : beansOfType.keySet()) {
      System.out.println("key = " + key + " value=" +
          beansOfType.get(key));
    }
  }
}

정상 등록되어있는지 코드로 확인할 수 있다.

 

📝Spring Bean 컨테이너 등록 과정

김영한 스프링 핵심 원리 기본편
김영한 스프링 핵심 원리 기본편
김영한 스프링 핵심 원리 기본편
김영한 스프링 핵심 원리 기본편

 

반응형
반응형

 

"김영한 스프링 핵심 원리 기본편" 내용을 기반으로 작성한 내용입니다.

 

스프링 핵심 원리 - 기본편 강의 | 김영한 - 인프런

김영한 | 스프링 입문자가 예제를 만들어가면서 스프링의 핵심 원리를 이해하고, 스프링 기본기를 확실히 다질 수 있습니다., 스프링 핵심 원리를 이해하고, 성장하는 백엔드 개발자가 되어보

www.inflearn.com

 

📝스프링의 핵심 기능 사용하기 전

MemberServiceImpl

public class MemberServiceImpl implements MemberService {
  private final MemberRepository memberRepository = new
      MemoryMemberRepository();
      
  public void join(Member member) {
    memberRepository.save(member);
  }
  
  public Member findMember(Long memberId) {
    return memberRepository.findById(memberId);
  }
}

 

 

MemberService

public interface MemberService {
  void join(Member member);
  Member findMember(Long memberId);
}

위 코드는 회원가입하고 회원을 찾는 로직들이 들어간 코드들이다. MemberServiceImple에서 new MemoryMemberRepository()를 통해 Repository를 어떤 걸 쓸지 직접 정해주고 있어서 OCP/DIP를 위반하고 있다.

 

 

📝스프링의 핵심 기능 사용하기 후

AppConfig

public class AppConfig {
  public MemberService memberService() {
    return new MemberServiceImpl(new MemoryMemberRepository());
  }
}

 

 

MembmerServiceImpl

public class MemberServiceImpl implements MemberService {
  private final MemberRepository memberRepository;
  
  public MemberServiceImpl(MemberRepository memberRepository) {
    this.memberRepository = memberRepository;
  }
  
  public void join(Member member) {
    memberRepository.save(member);
  }
  
  public Member findMember(Long memberId) {
    return memberRepository.findById(memberId);
  }
}

 

MembmerService

public interface MemberService {
  void join(Member member);
  Member findMember(Long memberId);
}

AppConfig에서 New해서 관리하기 때문에 더이상 MemberServiceImpl에서 MemberRepository를 New로 넣을 필요 없고 코드 수정도 필요가없다. 이렇게 함으로 OCP/DIP를 MemberServiceImpl은 지킬 수 있고 그 책임을 AppConfig에서 하게 된다.

 

 

📝IoC / DI 컨테이너

프로그램의 제어 흐름을 직접 제어하는 것이 아니라 외부에서 관리하는 것을 제어의 역전(IoC)라고 한다. 위에 코드로 이야기하자면 AppConfig에서 모두 관리하기 때문에 이걸 IoC 컨테이너 또는 DI(의존 주입) 컨테이너라고 한다.

 

위 예시로 설명하면 MemberService에 대한 Repository 제어를 MemberService에서 하는 게 아니라 AppConfig에서 하기 때문에 제어가 역전되었다라고 이야기하고 DI 즉, 의존을 주입하는 역할을 해서 DI 컨테이너라고 불리는 것이다.

 

 

반응형
반응형

📝Junit5

JunitJava에서 가장 많이 사용되는 테스트 프레임워크로 단위 테스트를 작성하고 실행하는데 사용됩니다.

 

 

📝테스트 코드 작성팁

  • 일반적으로 테스트 코드를 작성할 때에는 순수 자바코드로만 실행 가능하게끔 만드는 게 좋다. (스프링에 종속되거나 하지 않게끔)
  • given, when, then의 원칙을 지키면서 작성하면 좋다.
  • 테스트가 실패하는 경우도 테스트를 만들어야한다.

 

📝Junit5 예제 코드

package com.spring.core.member;

import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;

public class MemberServiceTest {

  MemberService memberService = new MemberServiceImpl();

  @Test
  void join() {
    // given
    Member member = new Member (1L, "memberA", Grade.VIP);

    // when
    memberService.join(member);
    Member findMemmber = memberService.findMember(1L);

    // then
    Assertions.assertThat(member).isEqualTo(findMemmber);

  }

}

@Test단위테스트 실행 단위를 설정한다.

 

package com.spring.core.discount;

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

import com.spring.core.member.Grade;
import com.spring.core.member.Member;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

class RateDiscountPolicyTest {
  RateDiscountPolicy discountPolicy = new RateDiscountPolicy();
  @Test
  @DisplayName("VIP는 10% 할인이 적용되어야 한다.")
  void vip_o() {
    //given
    Member member = new Member(1L, "memberVIP", Grade.VIP);
    //when
    int discount = discountPolicy.discount(member, 10000);
    //then
    assertThat(discount).isEqualTo(1000);
  }
  @Test
  @DisplayName("VIP가 아니면 할인이 적용되지 않아야 한다.")
  void vip_x() {
    //given
    Member member = new Member(2L, "memberBASIC", Grade.BASIC);
    //when
    int discount = discountPolicy.discount(member, 10000);
    //then
    assertThat(discount).isEqualTo(0);
  }
}

@DisplayName으로 Test 명명이 가능하다. (실패케이스와 성공케이스 두개 다 설정)

 

 

class MemberServiceTest {
  MemberService memberService;
  @BeforeEach
  public void beforeEach() {
    AppConfig appConfig = new AppConfig();
    memberService = appConfig.memberService();
  }
  
  @AfterEach
  void afterEach() {
     memberRepository.clearStore();
  }
}

@BeforeEach테스트 코드를 실행하기 전에 실행시켜야할 것들을 작성할 수 있다.

@AfterEach의 경우 테스트 코드를 실행한 후 실행시켜야할 것들을 작성할 수 있다.

 

반응형
반응형

 

"김영한 스프링 핵심 원리 기본편" 내용을 기반으로 작성한 내용입니다.

 

스프링 핵심 원리 - 기본편 강의 | 김영한 - 인프런

김영한 | 스프링 입문자가 예제를 만들어가면서 스프링의 핵심 원리를 이해하고, 스프링 기본기를 확실히 다질 수 있습니다., 스프링 핵심 원리를 이해하고, 성장하는 백엔드 개발자가 되어보

www.inflearn.com

 

 

 

📝스프링 등장배경

옛날에는 EJB라는 프레임워크가 있었지만 너무 사용하기 어렵고 비용도 많이 들고 느리기 때문POJO(Plain한 상태)로 생각하자 해서 나온 게 Spring의 근간이 되는 부분이다. 그리고 EJB에서 사용했던 Entity Bean의 경우는 Hibernate가 대체하게 되었고 표준안이 된 게 JPA이다.

 

 

스프링 변경 순서

  • EJB Entity Bean → Hibernate → JPA
  • EJB → Spring

 

📝Spring Framework

Spring Framework는 스프링에 들어가는 핵심기술이 다 들어간 프레임워크이다.

 

📝Spring Boot

Spring Boot는 Spring Framework를 쉽게 사용할 수 있게 도와준다.

  • 스프링 설정편해졌다.
  • 내장 서버를 지원해 따로 서버를 깔 필요가 없다. (예를 들면 톰캣)
  • 외부라이브러리 버전 호환성을 알아서 잘 처리해준다.
  • 모니터링도 지원한다.

 

📝 좋은 객체지향이란?

다형성

"다양한 형태를 가질 수 있다" 라는 의미로 예를 들면 마우스가 고장나면 다른 마우스를 꽂아도 똑같이 동작하는 것처럼 USB포트의 설계만 동일하면 변경에 유연하고 용이하다.

 

객체 설계시에는 역할과 구현을 명확히 분리해야한다. 자바로 따지면 역할은 인터페이스이고 구현은 인터페이스를 이용한 클래스를 의미한다. 즉, 클라이언트는 인터페이스만 알면 된다. (엑셀을 밟으면 움직인다 / 브레이크를 밟으면 멈춘다)

 

인터페이스를 잘 설계했으면 클라이언트에서 따로 변경하지 않더라도 인터페이스를 이용한 클래스만 바꾸면 된다. 그래서 인터페이스 변화가 없게 설계하는게 정말 중요하다

 

 

 

📝 SOLID원칙

클린코드로 유명한 로버트 마틴이라는 사람이 좋은 객체 지향 설계를 위해 5가지 원칙을 정리한 것이다.

 

SRP (단일 책임 원칙)

하나의 클래스는 하나의 책임만 가져야한다. 즉, 변경이 있을 때 파급 효과가 적으면 해당 원칙을 잘 따른 것이다. 예를 들면 UI 변경시 모든 코드를 다 바꿔야하면 해당 원칙을 잘못 활용한 것이다.

 

OCP (개방 폐쇄 원칙)

확장에는 열려있지만 변경에는 닫혀있어야한다.

 

// 기존 코드
public class MemberService {
 private MemberRepository memberRepository = new MemoryMemberRepository();
}

// 변경 코드
public class MemberService {
// private MemberRepository memberRepository = new MemoryMemberRepository();
 private MemberRepository memberRepository = new JdbcMemberRepository();

}

위 코드를 보면 직접 코드를 변경해야하는 문제점이 있다. 즉, 다형성을 사용했지만 직접 주입 클래스를 바꿔야하기 때문에 OCP 원칙을 지킬 수 없다. 이럴 경우 객체를 생성하고 연관관계를 맺어주는 별도의 조립, 설정자가 필요하다

 

 

LSP (리스코프 치환 원칙)

다형성에서 하위 클래스는 인터페이스 규약을 지켜야한다. 예를 들면 엑셀을 밟으면 앞으로 나가는 게 일반적이지만 뒤로 가게도 만들 수 있는데 뒤로 가게끔 만들면 해당 원칙을 위반한 것이다.

 

ISP 인터페이스 분리 원칙

범용 인터페이스 하나보단 여러개의 인터페이스가 좋다. 예를 들면 자동차 인터페이스를 운전, 정비 인터페이스를 분리시키면 정비 인터페이스가 바뀌더라도 운전 인터페이스에 영향을 끼치지 않는다.

 

DIP 의존관계 역전 원칙

프로그래머는 추상화에 의존해야지 구체화에 의존하면 안된다. 즉, 인터페이스에 의존해야지 클래스에 의존하면 안 된다. 예를 들면 로미오라는 배역이라는 역할 자체가 바뀌면 안 되지 로미오를 연기하는 사람은 바뀌어도 괜찮다.

 

📝 SOLID 문제점

다형성 만으로는 OCP와 DIP 즉, 직접 코드를 프로그래머가 바꿔줘야하는 문제점을 해결할 수 없다. 이걸 해결하기 위해 스프링이 나오게 되었다.

 

 

 

 

 

반응형
반응형

📝프로젝트 구조 (Package structure)

Spring Boot에서 정해둔 프로젝트 구조는 없지만 저는 DDD가 유지보수에 더 좋다고 생각하여 DDD 기반으로 만들었습니다

 

DAO 기반의 DDD

com
  └ lsj
      └  shopping_mall
 	  	  └ dashboard
		  |	  └  controller
		  |	  └  service
		  |	  └  dao
		  |	  └  dto
		  |	      └ request
		  |	      └ response
		  |	  └  util
		  |	  └  exception
		  |	  
		  |
		  └ global
		        └ config
		        └ user
		        └ exception
		        └ jwt
		        └ util (공통 API)

 

Repository 기반의 DDD (+ JPA)

com
  └ lsj
      └  shopping_mall
 	  	  └ dashboard
		  |	  └  controller
		  |	  └  service
		  |	  └  repository
		  |	  └  entity
		  |	  └  dto
		  |	      └ request
		  |	      └ response
		  |	  └  util
		  |	  └  exception
		  |	  
		  |
		  └ global
		        └ config
		        └ user
		        └ exception
		        └ jwt
		        └ util (공통 API)

 

📝DAO vs Repository

DAO

// User.java
public class User {
    private Long id;
    private String name;
    private String email;

    // Constructors, getters and setters
}

// UserDao.java
public interface UserDao {
    User findById(Long id);
    List<User> findAll();
    void save(User user);
    void update(User user);
    void delete(Long id);
}

// UserDaoImpl.java
public class UserDaoImpl implements UserDao {
    private DataSource dataSource;

    public User findById(Long id) {
        // SQL 쿼리를 사용하여 특정 사용자 검색
    }

    public List<User> findAll() {
        // 모든 사용자를 검색하는 SQL 쿼리
    }

    public void save(User user) {
        // 사용자 저장 SQL 쿼리
    }

    public void update(User user) {
        // 사용자 정보 업데이트 SQL 쿼리
    }

    public void delete(Long id) {
        // 사용자 삭제 SQL 쿼리
    }
}

DAO는 데이터베이스와의 상호 작용을 캡슐화하여 데이터베이스 접근 로직과 비즈니스 로직을 분리합니다 특히 CRUD연산에만 초점을 맞춥니다 (DAO의 경우 데이터 액세스를 추상화)

 

위 코드를 CRUD로 구분하면 아래와 같습니다

  • Create
    • save
  • Read
    • findById
    • findAll
  • Update
    • update
  • Delete
    • delete

 

Repository

// UserRepository.java
public interface UserRepository {
    User findById(Long id);
    List<User> findAllByStatus(String status);
    void save(User user);
    void delete(User user);
}

// UserRepositoryImpl.java
public class UserRepositoryImpl implements UserRepository {
    private EntityManager entityManager;  // JPA 사용 예시

    public User findById(Long id) {
        return entityManager.find(User.class, id);
    }

    public List<User> findAllByStatus(String status) {
        return entityManager.createQuery("SELECT u FROM User u WHERE u.status = :status", User.class)
                            .setParameter("status", status)
                            .getResultList();
    }

    public void save(User user) {
        entityManager.persist(user);
    }

    public void delete(User user) {
        entityManager.remove(user);
    }
}

DAO와 다르게 도메인 중심의 설계에서 사용되며 CRUD에서 확장되어 각 상황에 맞는 도메인 로직에 더 초점을 맞춥니다

 

반응형
반응형

 

📝전체 URL 적용

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class CorsConfig implements WebMvcConfigurer {

    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**")
            .allowedOrigins("*") // 모든 origin 허용 (보안상 주의)
            .allowedMethods("GET", "POST", "PUT", "DELETE")
            .allowedHeaders("*");
    }
}

 

  • addMapping
    • 내가 작성한 어떤 라우팅에 대해서 CORS를 허용할 지
  • allowedOrigins
    • 어떤 요청자에 대해서 허용시킬 것인지
  • allowedMethods
    • 어떤 HTTP 메소드에 대해서 허용할지
  • allowedHeaders
    • 어떤 헤더 값에 대해서 허용할지

 

📝부분 라우팅 적용

@CrossOrigin(origins = "*")
@GetMapping("/next")
public @ResponseBody HashMap<String, Object> next() throws InterruptedException {

	System.out.println("next2 call!!");
	HashMap<String, Object> map = new HashMap<String, Object>();
	map.put("id", "Next 테스트");
	
	Thread.sleep(3000);
	
	return map;
}
반응형
반응형

 

 

 

반응형
반응형

Enum은 열거형이라는 뜻을 가지고 있다 Enum이라는 타입을 사용할 시 Enum에서 설정한 데이터만 사용할 수 있다 예를 들면 '요일' "월, 화, 수, 목, 금, 토, 일"이 있다 해당 요일 외에 데이터는 받지 않기 때문에 컴파일 에러로 사전에 버그를 잡아낼 수 있다

 

Enum에 다양한 메소드가 존재한다

 

📝name()

enum Week {
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY
}



Week week = Week.FRIDAY;

String weekName = week.name();
System.out.println(weekName); // FRIDAY

enum의 값을 String으로 반환해준다

 

📝예제

import java.util.Arrays;

public enum AreaEnum {

    SEOUL("서울",1),
    INCHEON("인천",2),
    GYEONGGI("경기",31);

    private final String name;
    private final int code;


    AreaEnum(String name, int code) {
        this.name = name;
        this.code = code;
    }

    public String getName() {
        return this.name;
    }

    public int getCode() {
        return this.code;
    }


    public static String getByCode(int code) {
        Arrays.stream(values())
                .filter(area -> area.getCode() == code)
                .findFirst()
                .map(AreaEnum::getName)
                .orElse(null);
    }

}
반응형
반응형

 

📝Boolean OR절 축약

int areaCode = detail.get("areaCode").asInt();
boolean isAreaCodeValid = areaCode == 1 || areaCode == 2 || areaCode == 31;

 

반응형