스프링 입문 - (8) 회원 관리 예제

 

비즈니스 요구사항 정리

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

 

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

 

회원 객체

domain 패키지에 Member 클래스 생성 

 

hello.hellospring.domain

package 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;
    }
}

 

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

repository 

회원객체를 저장하기 위한 저장소

 

MemberRepository 인터페이스 생성 

package hello.hellospring.repository;

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

 

자바의 Interface 문법 

void feed(Tiger tiger) { // 호랑이가 오면 사과를 던져 준다. System.out.println("feed apple"); }

 

void feed(Lion lion) { // 사자가 오면 바나나를 던져준다. System.out.println("feed banana");

 

입력값의 자료형 타입이 다를 경우(위에서는 Tiger, Lion으로 서로 다르다) 메서드 명을 동일하게(여기서는 메서드명이 feed로 동일하다) 사용할 수 있다.

이런것을 메서드 오버로딩(Method overloading)이라고 한다.

 

동물원에 호랑이와 사자뿐이라면 ZooKeeper 클래스는 더 이상 할일이 없겠지만

악어, 표범 등이 계속 추가된다면 ZooKeeper는 육식동물이 추가될 때마다 매번 다음과 같은 feed 메서드를 추가해야 한다.

 

이런 어려움을 극복하기 위해서는 인터페이스의 도움이 필요하다.

 

인터페이스는 interface 키워드를 통해 선언할 수 있으며 implements 키워드를 통해 일반 클래스에서 인터페이스를 구현

 

interface Predator {

String getFood();

}

 

 

인터페이스의 메서드는 메서드의 이름과 입출력에 대한 정의만 있고 그 내용은 없다.

그 이유는 인터페이스는 규칙이기 때문이다.

위에서 설정한 getFood라는 메서드는 인터페이스를 implements한 클래스들이 구현해야만 하는 것이다.

 

class Tiger extends Animal implements Predator {

public String getFood() {

return "apple";

  }

}

 

인터페이스의 메서드는 항상 public으로 구현해야 한다.

 

https://wikidocs.net/217

05-07 인터페이스

 

 

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

 

MemoryMemberRepsoitory 클래스 생성 

package hello.hellospring.repository;

import hello.hellospring.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());
    }
}

 

 

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

store에 넣기전에  member에 sequence 값을 올려 id 값을 세팅

 

 

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

ofNullalbe() : null 이여도 감쌀 수 있도록 

 

 

Optional이란? 

 NPE(NullPointerException) 이란? ]

개발을 할 때 가장 많이 발생하는 예외 중 하나가 바로 NPE(NullPointerException)이다.

NPE를 피하려면 null 여부를 검사해야 하는데, null 검사를 해야 하는 변수가 많은 경우 코드가 복잡해지고 번거롭다.

그래서 null 대신 초기값을 사용하길 권장하기도 한다.

 

[ Optional이란? ]

Java8에서는 Optional <T> 클래스를 사용해 NPE를 방지할 수 있도록 도와준다. 

Optional<Optional <T>는null이 올 수 있는 값을 감싸는 Wrapper 클래스로, 참조하더라도 NPE가 발생하지 않도록 도와준다. Optional 클래스는 아래와 같은 value에 값을 저장하기 때문에 값이 null이더라도 바로 NPE가 발생하지 않으며,

클래스이기 때문에 각종 메서드를 제공해 준다.

 

 

 

https://mangkyu.tistory.com/70

 

 

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

 

람다(Lambda)

자바는 Java 8 버전부터 함수형 프로그래밍을 지원하기 위해 람다(Lambda)와 스트림(Stream)이 도입되었다.

람다와 스트림을 사용하면 요새 유행하는 함수형 프로그래밍 스타일로 자바 코드를 작성할 수 있다.

람다와 스트림을 사용하는 이유는 작성하는 코드의 양이 줄어들고 읽기 쉬운 코드를 만드는데 유리하기 때문이다.

 

람다식을 간단히 정의하면 다음과 같습니다.

식별자 없이 실행 가능한 함수 표현식

 

Calculator 인터페이스를 구현한 MyCalculator 클래스를 생성하였다.

그러면 이제 MyCalculator 클래스는 다음처럼 사용할 수 있다.

interface Calculator {
    int sum(int a, int b);
}

class MyCalculator implements Calculator {
    public int sum(int a, int b) {
        return a+b;
    }
}

public class Sample {
    public static void main(String[] args) {
        MyCalculator mc = new MyCalculator();
        int result = mc.sum(3, 4);
        System.out.println(result);  // 7 출력
    }
}

 

람다를 적용한 코드

이제 위에서 작성한 코드를 다음처럼 람다를 적용한 코드로 바꾸어 보자.

interface Calculator {
    int sum(int a, int b);
}

public class Sample {
    public static void main(String[] args) {
        Calculator mc = (int a, int b) -> a +b;
        int result = mc.sum(3, 4);
        System.out.println(result);
    }
}

위 코드에서 사용한 람다 함수는 다음과 같다.

(int a, int b) -> a +b

 

Stream

 

스트림의 사전적 의미는 '흐르다' 또는 '개울'입니다. 프로그래밍에서의 스트림도 사전적 의미와 크게 다르지 않습니다.

다만, 여기서는 물이 흐르는 것은 아니고 '데이터의 흐름'을 말합니다.

 

 

 

뭔가 추상적으로는 대충 데이터가 흐르겠구나.

 

컬렉션, 배열 등에 저장된 요소들을 하나씩 참조하면서 코드를 실행할 수 있는 기능입니다.

Stream을 사용하면, 불필요한 for문을 사용하지 않을 수 있고, 람다식을 활용할 수 있어서 코드를 직관적이게 처리할 수 있습니다.

 

 

스트림 생성하기 

 

 

스트림의 중간 연산 목록 

- Stream<T> distinct() 									#중복을 제거
- Stream<T> filter(Predicate<T> predicate) 				#조건에 안 맞는 요소 제외
- Stream<T> limit(long maxSize) 						#스트림의 일부를 잘라냄
- Stream<T> skip(long n) 								#스트림의 일부를 건너뜀
- Stream<T> peek(Consumer<T> action) 					#스트림의 요소에 작업수행
- Stream<T> sorted()									#스트림의 요소를 정렬
  Stream<T> sorted(Comparator<T> comparator) 		
- Stream<R>    map(Function<T,R> mapper)				#스트림의 요소를 변환
  DoubleStream mapToDouble(ToDoubleFunction<T> mapper)
  IntStream    mapToInt(ToIntFunction<T> mapper)
  LongStream   mapToLong(ToLongFunction<T> mapper)
  Stream<R>    flatmap(Function<T,Stream<R>> mapper)
  DoubleStream flatMapToDouble(Function<T,DoubleStream> m)
  IntStream    flatMapToInt(Function<T,IntStream> m)
  LongStream   flatMapToLong(Function<T,LongStream> m)

 

스트림의 최종 연산 목록

- void forEach(Consumer<? super T> action)				 #각 요소에 지정된 작업 수행
  void forEachOrdered(Consumer<? super T> action)
- long count()											 #스트림의 요소의 개수 반환
- Optional<T> max(Comparator<? super T> comparator)      #스트림의 최대값/최소값을 반환
  Optional<T> min(Comparator<? super T> comparator)
- Optional<T> findAny()		# 아무거나 하나				 #스트림의 요소 하나를 반환
  Optional<T> findFirst()	# 첫 번째 요소				
- boolean allMatch(Predicate<T> p) # 모두 만족하는지		#주어진 조건을 모든 요소가 만족시키는지, 만족시키지 않는지 확인
  boolean anyMatch(Predicate<T> p) # 하나라도 만족하는지
  boolean noneMatch(Predicate<> p) # 모두 만족하지 않는지
- Object[] toArray()
  A[]      toArray(IntFunction<A[]> generator)			 # 스트림의 모든 요소를 배열로 반환
- Optinal<T> reduce(BinaryOperator<T> accumulator)		  #스트림의 요소를 하나씩 줄여가면서(리듀싱) 계산
  T reduce(T identity, BinaryOperator<T> accumulator)
  U reduce(U identity, BiFunction<U,T,U> accumulator,BinaryOperator<U> combiner)
- R collect(Collector<T,A,R> collector)					  #스트림의 요소를 수집한다. 주로 요소를 그룹화 하거나 분할한 결과를 컬렉션에 담에 반환하는데 사용한다.

 

https://velog.io/@chamominedev/%EC%8A%A4%ED%8A%B8%EB%A6%BCstream%EC%9D%B4%EB%9E%80-%EB%AC%B4%EC%97%87%EC%9D%B8%EA%B0%80

 

 

Stream.filter()

filter()는 인자로 함수를 받으며, 어떤 조건으로 Stream의 요소들을 필터링합니다.

여기서 인자로 전달되는 함수를 구현하여 필터링하는 조건을 설정할 수 있습니다.

아래 예제는 filter()를 사용하여 Stream의 요소들 중에 "c"로 시작하는 문자열들을 모두 필터링합니다.

 

List<String> list =
        Arrays.asList("a1", "a2", "b1", "b2", "c2", "c1", "c3");
Stream<String> stream = list.stream();
Stream<String> filtered = stream.filter(s -> s.startsWith("c"));
filtered.forEach(System.out::println);

Output:

c2
c1
c3

 

배열 스트림

스트림을 이용하기 위해서는 먼저 생성을 해야 합니다.

스트림은 배열 또는 컬렉션 인스턴스를 이용해서 생성할 수 있습니다.

배열은 다음과 같이 Arrays.stream 메소드를 사용합니다.

1. String[] arr = new String[]{"a", "b", "c"};
2. Stream<String> stream = Arrays.stream(arr);
3. Stream<String> streamOfArrayPart = 
4.  Arrays.stream(arr, 1, 3); // 1~2 요소 [b, c]

 

 

Java - Stream findAny()

Stream에서 어떤 조건에 일치하는 요소(element) 1개를 찾을 때, findAny()와 findFirst() API를 사용할 수 있습니다.

 

findAny()는 Stream에서 가장 먼저 탐색되는 요소를 리턴하고, 

findFirst()는 조건에 일치하는 요소들 중에 Stream에서 순서가 가장 앞에 있는 요소를 리턴합니다.

 

 

 

https://codechacha.com/ko/java8-stream-difference-findany-findfirst/

 

 

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

 

 

03-08 맵 (Map)

 맵(Map)의 가장 큰 특징이라면 key로 value를 얻어낸다는 점이다. 

맵(Map)은 사전(dictionary)과 비슷하다

 

key                        value

people	사람
baseball	야구

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

map.put("people", "사람");

map.put("baseball", "야구");

 

key와 value는 위 예제에서 보듯이 put 메서드를 이용하여 추가할 수 있다.

 

System.out.println(map.get("people")); // "사람" 출력

 

key에 해당하는 value값을 얻기 위해서는 get 메서드를 사용한다.

map 객체의 키(Key) "people"에 대응하는 값(Value) "사람"이 출력된다.

 

https://wikidocs.net/208

 

 

 

---