WOO L' Techlog

좋은 객체 지향 프로그래밍 SOLID

실무에서는 비즈니스 요구사항이 굉장히 자주 바뀌기 때문에 OCP와 DIP를 준수하는 것이 변경사항에 대비하기 유리하다고 한다. 

* 아래 코드는OCP와 DIP를 위반한 예제 코드다. 

public class OrderServiceImpl implements OrderService {
// private final DiscountPolicy discountPolicy = new FixDiscountPolicy();
 private final DiscountPolicy discountPolicy = new RateDiscountPolicy();
}

실제 주문서비스를 기능하기 위한 OrderServiceImpl(구현체)는 OrderService(인터페이스)를 상속받아 생성된다.

이때, 할인 정책을 도입하기 위해 DIscountPolicy(인터페이스)에 의존관계를 가지며 private final을 통해 외부에서 고정된 값으로 실제 할인정책(구현체)를 사용한다.

-> //주석 처리를 통해 Fix에서 Rate 정책으로 변경하려는 코드임을 알 수 있다.

OCP와 DIP 위반

2편에서 객체에 대해 설명하며 사용했던 그림이다.

OrderServiceImpl을 운전자라고 치자.

DiscountPolicy가 자동차 역할, FixDiscountPolicy와 RateDiscountPolicy는 K3, 아반떼, 모델3라고 할 수 있다.

운전자는 어딘가로 이동하겠다는 목적을 위해 자동차를 이용하고자 한다. 이때 자동차를 타고 이동하는 것이 중요한 것이지 어떤 기종을 타는지는 목적을 이루는데 중요하지 않다.

그러나, 위 예제 코드에서는 K3를 타도록 지정되어 있는 것과 같다. - DIP 위반!

그리고 외부 사정으로 인해 K3를 이용하기 어려워 아반떼로 변경되는 상황에서 운전자에게 변경 정보를 입력해 아반떼를 찾아 타게 만들어야 하는 것이다. - OCP위반 !

Config 구성 클래스

운전자가 자동차 운전(실행)에만 집중할 수 있도록 자동차 설정은 Config라는 구성클래스를 통해 따로 관리해야한다.

package hello.core.order;
import ...

public class OrderServiceImpl implements OrderService {
	private final MemberRepository memberRepository;
	private final DiscountPolicy discountPolicy;
	public OrderServiceImpl(MemberRepository memberRepository, DiscountPolicy
discountPolicy) {
 		this.memberRepository = memberRepository;
 		this.discountPolicy = discountPolicy;
 	}
 	@Override
	public Order createOrder(Long memberId, String itemName, int itemPrice) {
		Member member = memberRepository.findById(memberId);
 		int discountPrice = discountPolicy.discount(member, itemPrice);
 		return new Order(memberId, itemName, itemPrice, discountPrice);
 	}
}

package hello.core;
import ...

public class AppConfig {
	public MemberService memberService() {
		return new MemberServiceImpl(new MemoryMemberRepository());
	}
 	public OrderService orderService() {
 	return new OrderServiceImpl(
 		new MemoryMemberRepository(),
 		new FixDiscountPolicy());
 	}
}

• 위 코드는 OrderService메서드에서 OrderServiceImpl 구현체를 생성하고 생성자 주입을 통해 FixDiscountPolicy 구현체를 주입하고 있다.
• 아래 코드는 수정된 OrderServiceImpl 클래스다. DiscountPolicy만 의존관계를 갖고 나머지는 생성자 주입을 통해 구현체를 관리한다.

OrderServiceImpl과 Appconfig 클래스는 각각 역할을 구분하여 책임을 부여하고 있다. 이를 통해 각 클래스가 어떤 역할을 하는지 명확하게 확인할 수 있고 변경사항에도 대비할 수 있다.

Config클래스의 추가적인 기능 설명

들어가며

안녕하세요,😎😎😎

3편에 들어서야 드디어 개발과 관련이 있는 정리글을 쓸 수 있게 되었습니다. 필수 아닌 필수(?)라서 기술 블로그를 시작했는데 생각보다 많이 어렵네요,,,

그래도 하루 한 편을 목표로 취업할때까지는 꾸준히 작성해보겠습니다.!

회원 도메인 설계

1. 회원 도메인 요구사항
2. 회원을 가입하고 조회할 수 있다.
3. 회원은 일반과 VIP 두 가지 등급이 있다.
4. 회원 데이터는 자체 DB를 구축할 수 있고, 외부 시스템과 연동할 수 있다. (미확정)

클라이언트는 가입과 조회 서비스를 요청할 수 있으며, 멤버 데이터를 저장하고 조회하는 기능을 추상화하여 인터페이스를 통해 정의하고, 이를 구현하는 구체적인 클래스를 통해 실제 기능을 구현하고 사용할 수 있도록 합니다.

회원 클래스 Member Class

가장 기초적인 회원 도메인에 대한 클래스는 멤버 변수/ 생성자/ 게터 및 세터로 구성됩니다.

1. 멤버 변수는 private로 작성하여 외부로부터 접근을 차단합니다.
2. 생성자는 멤버 객체를 생성할 때 초기화하는 역할을 합니다.
3. 게터 및 세터를 통해 외부에서 변수를 설정하고 호출할 수 있습니다.

package hello.core.member;
// Member 변수 생성
public class Member {
    private Long id;
    private String name;
    private Grade grade;
// 생성자
    public Member(Long id, String name, Grade grade) {
        this.id = id;
        this.name = name;
        this.grade = grade;
    }
//get과 set으로 변수 설정 및 호출
    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;
    }

    public Grade getGrade() {
        return grade;
    }

    public void setGrade(Grade grade) {
        this.grade = grade;
    }
}

회원 서비스 인터페이스 Member Service Interface

클라이언트의 가입과 조회 서비스 요청

서비스 기능은 비교적 간단하다. 가입과 조회를 위해 join 메서드와 findMember 메서드를 이용했다.

그리고 가입을 위해 입력 받은 값이 어딘가 저장되어 있어야 조회도 가능할 것이다.

package hello.core.member;

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

회원 저장소 인터페이스 Member Repository Interface

멤버 데이터를 저장하고 조회하는 기능을 추상화

서비스(Service)와 저장소(Repository)를 분리하여, 각 역할을 명확하게 구분하였고 쉽게 확장이 가능하다.

package hello.core.member;

public interface MemberRepository {
    void save(Member member);
    Member findById(Long memberId);
}

구체적인 클래스 생성 MemberServiceImpl

구체적인 클래스를 통해 실제 기능을 구현 하기 위해 회원 저장소를 불변 값으로 놓고 생성자를 통해 의존성을 주입하였다. -> DI원칙에 의해 작성되었으며, 이후 다른 저장소로 교체가 용이합니다.

public class MemberServiceImpl implements MemberService {

    private final MemberRepository memberRepository;

    // 생성자를 통해 MemberRepository 주입
    public MemberServiceImpl(MemberRepository memberRepository) {
        this.memberRepository = memberRepository;
    }

    @Override
    public void join(Member member) {
        memberRepository.save(member);
    }

    @Override
    public Member findMember(Long memberId) {
        return memberRepository.findById(memberId);
    }
}

메모리 저장소 MemoryMemberRepository

데이터베이스가 결정되지 않았으므로, 메모리에 저장하는 방식으로 구현된 것이다.

키-값 쌍을 저장하는 자료구조인 Map을 활용하여 store 변수를 생성, 변수는 HashMap 알고리즘을 통해 초기화한다.

자료구조와 알고리즘에 대해 추가적인 공부가 필요하다..

package hello.core.member;

import java.util.HashMap;
import java.util.Map;

public class MemoryMemberRepository implements MemberRepository {


    private static Map<Long, Member> store = new HashMap<>();
    @Override
    public void save(Member member) {
        store.put(member.getId(), member);
    }

    @Override
    public Member findById(Long memberId) {
        return store.get(memberId);
    }
}

들어가며

안녕하세요,

Spring 프레임워크와 관련해 시리즈로 글을 쓰기로 마음을 먹었는데,, 사실 인프런의 김영한 선생님 커리큘럼을 수강중이라 수강 후기에 가까울 것 같습니다. ㅎㅎ

이전 글에서는 대표적인 용어 개념을 정리한 것 같은데 이번 글에서는  객체 지향 프로그래밍의 개념에 대해 정리를 하려고 합니다. 

객체 지향 = 다형성?

객체 지향 프로그래밍의 정의는 위키백과에 따르면, 아래와 같다.

또한, 자바 언어 설명서에 의하면 객체는 클래스 인스턴스 또는 배열로 정의된다.

An object is a class instance or an array.

처음 들었을 때는 객체, 클래스, 인스턴스 등 이해되지 않는 말들 투성이였다.

그렇지만 개발자 = 창조자(god)에 비유하면 이해를 도울 수 있으리라 생각한다. 자, 우리는 어플리케이션이라는 세상을 창조하려고 한다. 세상을 구성하고 기능하게 하기 위해서는 피조물(객체)가 필요하다.

객체는 추상적, 구체적 정의로 나뉜다. 아래 그림을 예로 들면, K3, 아반떼, 모델3는 모두 자동차면서도 서로 구분이 된다. 여기서 자동차는 추상적 정의다. 우리의 머리 속에만 존재하는 개념.

A : 나 '자동차' 살거야.

B : 어떤 자동차?

A : K3!

A와 B는 모두 자동차에 대해 이야기를 하고 있지만, 실제로 사용하기 위해서는 '어떤 자동차'라는 구체적인 정의가 필요하다.

다형성은 자동차라는 클래스를 수만가지의 종류를 구현할 수 있음을 의미한다.

프로그래밍 관점에서 클라이언트가 '자동차를 타고 싶어'라고 요청을 보냈다면 K3를 타다가 아반떼를 타고 그리고 모델3로 바꿔 타도 문제가 없다.

인터페이스와 상속

그래서 자동차는 단순히 공통분모로 정의되는 개념일까? 

우리가 머리 속에 자동차를 떠올릴 때 생각나는 형태가 있을 것이다. 그 특징들의 차이로 K3, 아반떼, 모델3를 구분할 수 있다. 이 특징들은 매우 중요하고 이를 추상 메서드라고 한다.

추상 메서드는 추상 클래스와 인터페이스를 통해 상속되는 개념인데, 클래스는 하나의 추상 메서드만을 상속하지만, 인터페이스는 여러 개의 추상 메서드를 상속할 수 있다.

다만, 추상 메서드는 강제로 하위 클래스에서 구현되기 때문에 안정적인 설계가 중요하다.

글솜씨가 부족해 제대로 전달이 될 지 우려된다...

*동물을 키워드로 아래 코드를 보면 이해가 쉬울 것이라 생각한다.

// 동물을 나타내는 인터페이스
interface Animal {
    void makeSound(); // 추상 메서드: 동물의 울음 소리를 나타냄
}

// 각 동물을 구현하는 클래스
class Dog implements Animal {
    @Override
    public void makeSound() {
        System.out.println("멍멍!"); // 강아지는 멍멍 짖음
    }
}

class Cat implements Animal {
    @Override
    public void makeSound() {
        System.out.println("야옹!"); // 고양이는 야옹 소리
    }
}

class Duck implements Animal {
    @Override
    public void makeSound() {
        System.out.println("꽥꽥!"); // 오리는 꽥꽥 소리
    }
}

public class AnimalExample {
    public static void main(String[] args) {
        Animal dog = new Dog();
        Animal cat = new Cat();
        Animal duck = new Duck();

        dog.makeSound(); // 멍멍!
        cat.makeSound(); // 야옹!
        duck.makeSound(); // 꽥꽥!
    }
}

인터페이스의 다중 구현

FlyingFish는 Fly와 Swim 두가지 추상 메서드를 상속 받는다.

// 인터페이스 정의
interface Flyable {
    void fly();
}

interface Swimmable {
    void swim();
}

// 클래스가 두 인터페이스를 다중으로 구현
class FlyingFish implements Flyable, Swimmable {
    @Override
    public void fly() {
        System.out.println("Flying in the air!");
    }

    @Override
    public void swim() {
        System.out.println("Swimming in the water!");
    }
}

public class Main {
    public static void main(String[] args) {
        FlyingFish flyingFish = new FlyingFish();
        flyingFish.fly();  // Flying in the air!
        flyingFish.swim(); // Swimming in the water!
    }
}

백엔드 개발자를 선택하고 나서

개발자에게 프론트는 js, 백은 Java를 선택해야(?)만 할정도로 한국 사회에서 가장 널리 보급되고 있는 것 같다. 

이외에도 많지만 대표적으로 기본이 되는 것들을 추리면 이렇게 되는 것 같다. 위 기술들을 바탕으로 여러 언어와 기술을 습득해가는 방식(?). 모바일은 들어본게 Flutter라...

JDK와 IDE 선택

JDK는 자바 개발 키트의 약자로 자바 어플리케이션 개발을 위한 기본 도구다.

JDK안에는 JDE(자바 개발 환경), JVM(자바 가상 머신) 등이 포함되어 JAVA를 통해 어플리케이션을 개발할 수 있게 해주는 플랫폼이라고 생각하면 된다.

JDK를 설치하면 사실상 메모장을 통해서도 자바 어플리케이션을 만들 수 있다. 그러나, 백지 위에 모든 코드를 손수 쓰며 코딩하기에는 생산성이 떨어지므로, IDE라는 통합개발툴을 사용한다.

많이 쓰는 Oracle의 open JDK를 설치하였으며, Intellij(인텔리제이)의 Ultimate 버젼을 사용.

WAS(TOMCAT)과 Web서버

Web서버와 WAS의 차이는 가장 대표적으로는 '어떤 요청을 처리하는가'다.

• Web서버는 html, css, js등 정적인 요청을 수행하는 역할.
• WAS는 DB에서 데이터를 가져오거나, API를 호출하는 등 동적인 요청을 해결하는 역할.

위 그림과 같이 일반적으로 클라이언트의 요청을 받아 서버는 연결된 어플리케이션(+데이터베이스)의 동작을 반환한다.

따라서 '어떻게 효율적으로 반환할 수 있지?'라는 생각을 바탕으로 개발을 해나가는 것이 백엔드 개발자의 좋은 자세라고 생각한다.

MVC

좋은 반환(?)의 첫번째는 MVC 패턴이며, Chat-gpt에 따르면, MVC의 정의는 아래와 같다.

동작에 따라 3가지 큰 분류를 통해 로직을 짜는 방법이다. 

Controller가 클라이언트의 요청을 받고 Model에서 데이터를 추출해 View를 통해 반환한다.

*예시

@Controller
@RequestMapping("/example")
public class ExampleController {

    // "/example/hello"에 대한 GET 요청을 처리하는 메서드
    @GetMapping("/hello")
    public String hello() {
        return "helloPage";
    }

    // "/example/greet"에 대한 POST 요청을 처리하는 메서드
    @PostMapping("/greet")
    public String greet(@RequestParam String name, Model model) {
        model.addAttribute("name", name);
        return "greetPage";
    }
}

@Controller라는 어노테이션을 통해 위의 클래스가 컨트롤러임을 지정한다.

@___Mapping은 요청에 따라 메서드를 정하고 return 값을 통해 반환될 View를 지정한다.

자세한 내용은 HTTP 정리 글에서 다룰 예정이므로 간략하게 Mapping의 종류만 정리한다.

@GetMapping("/example")
public String example() {
    // ...
}

@PostMapping("/create")
public String create(@RequestBody DataObject data) {
    // ...
}

@PutMapping("/update/{id}")
public String update(@PathVariable Long id, @RequestBody UpdatedDataObject updatedData) {
    // ...
}

@DeleteMapping("/delete/{id}")
public String delete(@PathVariable Long id) {
    // ...
}

API

백엔드 개발자의 주업무라고 해야하나.. 회원, 상품, 주문, 정산 등 API개발을 한다.

하나의 소프트웨어는 컨포넌트의 집합이라고 할 수 있다. 그리고 컨포넌트 간의 통신을 돕는 것이 API의 역할이다.

*예시

@Service
public class MemberService {
    private final MemberRepository memberRepository;

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

    public void registerMember(Member member) {
        // 비즈니스 로직 수행, 예를 들어 중복 회원 검사 등
        if (isDuplicateMember(member)) {
            throw new IllegalStateException("이미 가입된 회원입니다.");
        }
        memberRepository.save(member);
    }

    private boolean isDuplicateMember(Member member) {
        // 중복 여부 검사 로직
    }
}


@Repository
public class MemberRepository {
    private final Map<Long, Member> store = new HashMap<>();
    private long sequence = 0L;

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

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

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

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


@Controller
public class MemberController {
    private final MemberService memberService;

    @Autowired
    public MemberController(MemberService memberService) {
        this.memberService = memberService;
    }

    @GetMapping("/members/{id}")
    public String getMemberById(@PathVariable Long id, Model model) {
        // 회원 조회 로직
        Member member = memberService.getMemberById(id);
        model.addAttribute("member", member);
        return "memberDetail";
    }

    @PostMapping("/members/new")
    public String registerNewMember(@ModelAttribute MemberForm form) {
        // 회원 가입 로직
        Member member = new Member();
        member.setName(form.getName());
        memberService.registerMember(member);
        return "redirect:/members/" + member.getId();
    }
}

ORM과 JPA 그리고 RDBMS

ORM -> JPA -> Spring Data JPA

-> 객체와 DB를 Mapping해서 SQL문 없이 반복적인 CRUD를 구현.

JPA와 Spring Data JPA 차이

JPA 예시:

//엔터티 클래스 (Entity Class):
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Member {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    // Getters, setters, 기타 메서드
}

//JPA를 사용한 Repository:
import javax.persistence.EntityManager;
import java.util.List;

public class MemberRepository {
    private final EntityManager em;

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

    public void save(Member member) {
        em.persist(member);
    }

    public Member findById(Long id) {
        return em.find(Member.class, id);
    }

    public List<Member> findAll() {
        return em.createQuery("SELECT m FROM Member m", Member.class)
                .getResultList();
    }

    // 기타 필요한 메서드들
}

//엔터티 매니저 활용:
EntityManager em = // 엔터티 매니저 생성 (예: EntityManagerFactory로부터)
MemberRepository repository = new MemberRepository(em);

Member member = new Member();
member.setName("John Doe");

repository.save(member);

Member foundMember = repository.findById(member.getId());
List<Member> allMembers = repository.findAll();

Spring Data JPA 예시:

//엔터티는 동일
//Spring Data JPA Repository:
import org.springframework.data.jpa.repository.JpaRepository;

public interface MemberRepository extends JpaRepository<Member, Long> {
    // JpaRepository에서 기본적인 CRUD 메서드들을 이미 제공받음
}

//Spring Data JPA 활용:
MemberRepository repository = // Spring이 자동으로 구현한 Repository 빈을 주입받음

Member member = new Member();
member.setName("John Doe");

repository.save(member);

Member foundMember = repository.findById(member.getId()).orElse(null);
List<Member> allMembers = repository.findAll();

@Bean 등록 - Config

@Configuration을 가진 클래스는 주로 @Bean을 등록해 DI(의존성 주입)을 한다.

Junit5

JUnit은 테스트 주도 개발(TDD) 및 소프트웨어 개발의 품질 향상을 위해 많이 사용되는 도구 중 하나로 단위 테스트를 통해 개발 코드를 리뷰한다.

*예시

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

public class MyTest {
    @Test
    public void testAddition() {
        assertEquals(4, 2 + 2);
    }
}