공통처리를 위해 활용 가능한 3가지

1. Filter
2. Interceptor
3. AOP

Spring에서의 흐름

• Interceptor와 Filter는 Servlet 단위에서 실행
• AOP는 메소드 앞에 Proxy패턴의 형태로 실행
• Filter → Interceptor → AOP → Interceptor → Filter 순

Filter(필터)

• J2EE 표준 스펙 기능
• 디스패처 서블릿(Dispatcher Servlet)에 요청이 전달 되기 전/후에 패턴에 맞는 모든 요청에 대해 부가작업을 처리할 수 있는 기능을 제공
• 웹 컨테이너에서 동작

Filter의 메소드

• init() : 필터 인스턴스 초기화
• doFilter() : 전/후 처리
• destroy() : 필터 인스턴스 종료

public interface Filter {

    public default void init(FilterConfig filterConfig) throws ServletException {}

    public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain) throws IOException, ServletException;

    public default void destroy() {}
}

필터의 용도

• 공통된 보안 및 인증/인가 관련작업
• 모든 요청에 대한 로깅 또는 감사
• 이미지/데이터 압축 및 문자열 인코딩
• Spring과 분리 되어야 하는 기능

Interceptor(인터셉터)

• Spring에서 제공하는 기술
• 디스패처 서블릿(Dispatcher Servlet)이 컨트롤러를 호출하기 전과 후에 요청과 응답을 참조하거나 가공할 수 있는 기능
• 스프링 컨텍스트에서 동작
• 핸들러 매핑의 결과로 실행체인(HandlerExecutionChain)이 나옴. → 인터셉터가 등록되어 있다면 순차적으로 인터셉터들을 거쳐 컨트롤러가 실행되도록 함.

인터셉터의 메소드

• preHandler() : 컨트롤러 메소드가 실행되기 전
• postHandler() : 컨트롤러 메소드 실행 직 후 / view 페이지 렌더링 전
• afterCompletion() : view 페이지 렌더링 후

public interface HandlerInterceptor {

    default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
        throws Exception {

        return true;
    }

    default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
        @Nullable ModelAndView modelAndView) throws Exception {
    }

    default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,
        @Nullable Exception ex) throws Exception {
    }
}

인터셉터의 용도

• 세부적인 보안 및 인증/인가 공통 작업
• API 호출에 대한 로깅 또는 감사
• Controller로 넘겨주는 정보 가공

필터 VS 인터셉터

Request/Response 조작 여부

• 필터는 가능하지만, 인터셉터는 불가능
• 조작이란 내부 상태를 변경하는 것이 아니라 다른 객체로 바꿔지기가 가능하다는 것

필터

public MyFilter implements Filter {

    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) {
        // 개발자가 다른 request와 response를 넣어줄 수 있음
        chain.doFilter(request, response);       
    }

}

인터셉터

public class MyInterceptor implements HandlerInterceptor {

    default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        // Request/Response를 교체할 수 없고 boolean 값만 반환할 수 있다.
        return true;
    }

}

Reference

https://mangkyu.tistory.com/173

List<String> names = new ArrayList<>();

names.add("chanhong");
names.add("pig");

• 연속된 데이터를 처리하는 연산(Operation)들의 모음

• Functional in nature, 스트림이 처리하는 데이터 소스를 변경하지 않는다.

    Stream<String> stringStream = neames.stream().map(String::toUpperCase);
  
    names.forEach(System.out::println);

• 스트림으로 처리하는 데이터는 오직 한번만 처리한다.

• 손 쉽게 병렬 처리할 수 있다. (parallelStream())

• 중개 오퍼레이션은 근본적으로 lazy하다.

스트림 파이프라인

• 0 또는 다수의 중계 오퍼레이션과 한개의 종료 오퍼레이션으로 구성된다.
• 스트림의 데이터 소스는 오직 터미널 오퍼레이션을 실행할 때에만 처리한다.

중개 오퍼레이션

• Stream을 리턴한다.

종료 오퍼레이션

• Stream을 리턴하지 않는다.

Stream<String> stringStream = names.stream().map((s) -> {
        System.out.println(s);
        return s.toUpperCase();
});

List<String> collect = names.stream().map((s) -> {
        System.out.println(s);
        return s.toUpperCase();
}).collect(Collectors.toList());

collect.forEach(System.out::println

스트림 API 사용 예제

List<OnlineClass> springClasses = new ArrayList<>();
        springClasses.add(new OnlineClass(1, "spring boot", true));
        springClasses.add(new OnlineClass(2, "spring data jpa", true));
        springClasses.add(new OnlineClass(3, "spring mvc", false));
        springClasses.add(new OnlineClass(4, "spring core", false));
        springClasses.add(new OnlineClass(5, "rest api development", false));

걸러내기

• Filter(Predicate)

System.out.println("spring 으로 시작하는 수업");
        springClasses.stream()
                .filter(oc -> oc.getTitle().startsWith("spring"))
                .forEach(oc -> System.out.println(oc.getId()));

변경하기

• Map 또는 FlatMap

System.out.println("수업 이름만 모아서 스트림 만들기");
        springClasses.stream()
                .map(oc -> oc.getTitle())
                .forEach(s -> System.out.println(s));

생성하기

• generate 또는 Iterate

System.out.println("10부터 1씩 증가하는 무제한 스트림 중에서 앞에 10개 빼고 최대 10개 까지만");
Stream.iterate(10, i -> i + 1)
                .skip(10)
                .limit(10)
                .forEach(System.out::println);

제한하기

• limit 또는 skip

System.out.println("자바 수업 중에 Test가 들어있는 수업이 있는지 확인");
        boolean test = javaClasses.stream().anyMatch(oc -> oc.getTitle().contains("Test"));
        System.out.println(test);

        System.out.println("스프링 수업 중에 제목에 spring이 들어간 것만 모아서 List로 만들기")
        List<String> spring = springClasses.stream()
                .map(OnlineClass::getTitle)
                .filter(t -> t.contains("spring"))
                .collect(Collectors.toList());
        spring.forEach(System.out::println);

함수형 인터페이스

• 추상 메소드를 딱 하나만 가지고 있는 인터페이스
• SAM (Single Abstract Method) 인터페이스
• @FunctionaInterface 애너테이션을 가지고 있는 인터페이스
• 추상 메소드만 1개이면 되고 static 메소드나 default 메소드는 여러 개 포함할 수 있습니다.
• 함수형 인터페이스를 이용해 람다 표현식을 구현(사용)할 수 있습니다.
• 람다를 구현하기 위해 함수형 인터페이스를 사용한다고 볼 수 있습니다.

@FunctionalInterface
public interface RunSomething {
        void doit();

        static void printName() {
                System.out.println("이름");
        }

        default void printAge() {
                System.out.println("나이");
        }
}

자바 8 이전

//익명 내부 클래스 
RunSomething runSomething = new RunSomeThing() {
        @Override
        public void doit() {
                System.out.println("Hello");
        }
}

자바 8 이후

RunSomething runSomething = () -> System.out.println("Hello");

RunSomething runSomething = () -> {
        System.out.println("Hello");
        System.out.println("lambda");
}

자바에서 함수형 프로그래밍

• 함수를 First class object로 사용할 수 있다.
• 순수 함수 (Pure function)
  • 사이드 이펙트 만들 수 없다. (함수 밖에 있는 값을 변경하지 못한다.)
  • 상태가 없다. (함수 밖에 정의되어 있는)
• 고차 함수 (High-Order Function)
  • 함수가 함수를 매개변수로 받을 수 있고 함수를 리턴할 수도 있다.
• 불변성

람다 표현식 (Lambda Expressions)

• 함수형 인터페이스의 인스턴스를 만드는 방법으로 쓰일 수 있다.
• 코드를 줄일 수 있다.
• 메소드 매개변수, 리턴 타입, 변수로 만들어 사용할 수도 있다.
• (인자 리스트) → {바디}

인자리스트

• 인자가 없을 때 : ( )
• 인자가 한개일 때 : (one) 또는 one
• 인자가 여러개 일 때 : (one, two)
• 인자의 타입은 생략가능, 컴파일러가 추론하지만 명시할 수도 있다.

바디

• 화살표 오른쪽에 함수 본문을 정의한다.
• 여러 줄인 경우에 { }를 사용해서 묶는다.
• 한 줄인 경우에 { } 생략 가능, return도 생략 가능

메소드 레퍼런스

• 람다가 하는 일이 기존 메소드 또는 생성자를 호출하는 거라면, 메소드 레퍼런스를 사용해 매우 간결하게 표현할 수 있다.

public class Greeting {
        private String name;

        public Greeting() {
        }

        public Greeting(String name) {
                this.name = name;
        }

        public String hello(String name) {
                return "hello " + name;
        }

        public static String hi(String name) {
                return "hi " + name;
        }
}

UnaryOperator<String> hi = (s) -> "hi " + s;

// 스태틱 메소드 참조
UnaryOperator<String> hi = Greeting::hi;

// 인스턴스 메소드 참조
Greeting greeting = new Greeting();
UnaryOperator<String> hi = greeting::hello;

// 기본 생성자
Supplier<Greeting> newGreeting = Greeting::new;

// 매개변수가 있는 생성자
Function<String, Greeting> newGreeting = Greeting::new;

Greeting greeting = newGreeting.get();

• 두 클래스가 서로 긴밀한 관계가 있을 떄 내부 클래스를 사용한다.
• 내부 클래스에서 외부 클래스의 멤버들을 쉽게 접근할 수 있다.
• 외부에는 불필요한 클래스를 감춰서 코드의 복잡성을 줄일 수 있다는 장점이 있다.
• 서로 관련 있는 클래스를 논리적으로 묶어서 표현함으로써, 코드의 캡슐화를 증가시킨다.

class A{    //외부클래스
    ...
    class B{    //내부클래스
        ...
    }
    ...
}

• 내부 클래스인 B는 외부 클래스인 A를 제외하고는 다른 클래스에서 잘 사용되지 않는 것이어야 한다.

내부 클래스의 종류와 특징

내부 클래스의 제어자와 접근성

• 내부 클래스 중 스태틱 클래스(static class)만 static 멤버를 가질 수 있다.
• final과 static이 동시에 붙은 변수는 상수 이므로 모든 클래스에 정의가 가능하다.
• 인스턴스 클래스와 스태틱 클래스는 외부 클래스의 멤버변수와 같은 위치에 선언되며, 또한 멤버 변수와 같은 성질을 가진다.

익명 클래스(Anonymous class)

public class Example {

    interface MyInterface {
        void doSomething();
    }

    public static void main(String[] args) {

        MyInterface myClass = new MyInterface() {
            @Override
            public void doSomething() {
                System.out.println("doSomething");
            }
        };
        myClass.doSomething();
    }
}

• 클래스의 선언과 객체의 생성을 동시에 하기 때문에 단 한 번만 사용될 수 있고 오직 하나의 객체만을 생성할 수 있는 일회용 클래스이다.
• 이름이 없기 때문에 생성자도 가질 수 없다.
• 단 하나의 클래스를 상속 받거나 단 하나의 인터페이스만을 구현할 수 있다.
• 익명 클래스는 이름이 없기 때문에 외부클래스명$숫자.class 형식으로 클래스 파일명이 결정된다.

• 인터페이스는 기능에 대한 선언만 가능, 실제 구현 로직은 포함될 수 없다.
• 자바 8부터 등장한 default 메소드는 인터페이스 내부에서도 로직이 포함된 메소드를 선언할 수 있게 한다.

interface MyInterface { 
    default void printHello() { 
        System.out.println("Hello World"); 
    } 
}

• 이를 구현하는 클래스는 @Override 가능하다.

default 메소드 등장 이유

• 자바 기본서 ‘자바의 신’에서는 default 메소드에 대한 존재 이유를 아래와 같이 설명한다.

• 인터페이스의 기본 구현을 그대로 상속하므로 인터페이스에 자유롭게 새로운 메소드를 추가할 수 있게 된다.
• 호환성을 유지하면서 API를 바꿀 수 있다.

1. 바이너리 호환성 : 변경 이후에도 에러 없이 기존 바이너리가 실행될 수 있는 상황
2. 소스 호환성 : 코드를 고쳐도 기존 프로그램을 성공적으로 재컴파일할 수 있는 상황
3. 동작 호환성 : 코드를 바꾼 다음에도 같은 입력값이 주어지면 같은 동작을 하는 상황

default 메소드의 규칙

1. 클래스가 항상 이긴다. 클래스나 슈퍼클래스에서 정의한 메소드가 디폴트 메소드보다 우선권을 갖는다.
2. 1번 규칙 이외의 상황에서는 서브 인터페이스가 항상 이긴다. 즉, B가 A를 상속받는 다면 B가 A를 이긴다.
3. 여전히 디폴트 메소드의 우선순위가 결정되지 않았다면 여러 인터페이스를 상속받은 클래스가 명시적으로 디폴트 메소드를 오버라이드 하고 호출해야한다.

public interface A {
    default void hello() {
        System.out.println("Hello from A");
    }
}

public interface B extends A{
    default void hello() {
        System.out.println("Hello from B");
    }
}

public class C implements B, A {
    public static void main(String args[]) {
        new C().hello();  //"Hello from B"가 출력됨!
    }
}

default 메소드의 활용

1. 선택형 메소드
2. 동작 다중 상속

미완성 설계도

• abstract 키워드를 붙이면 됨.
• 추상 클래스는 추상 메소드를 0개 이상 가지고 있다는 것을 제외하고 일반 클래스와 다르지 않음.
• 추상 메소드는 선언부는 있는데 구현부가 없는 메소드 자식 클래스에서 반드시 오버라이딩해야만 사용할 수 있는 메소드
• 추상 메소드를 포함하는 클래스는 반드시 초상 클래스여야 함.
• 다중 상속이 불가능
• 상속하는 집한간에는 연관관계가 존재
• 상속을 위한 클래스이기 때문에 객체(인스턴스)를 생성할 수 없음.

abstract class 클래스이름 {
    ...
    public abstract void 메서드이름();
}

• 추상 클래스를 상속받는 모든 클래스에서는 이 추상 메소드를 반드시 재정의 해야함. → 자식클래스에서 추상클래스의 모든 추상 메소드를 오버라이딩 하고 나서야 비로소 자식클래스의 인스턴스를 생성할 수 있음.
• 생성자와 필드, 일반 메소드 포함 가능

abstract class Animal { abstract void cry(); }

class Cat extends Animal { void cry() { System.out.println("냐옹냐옹!"); } }
class Dog extends Animal { void cry() { System.out.println("멍멍!"); } }


public class Polymorphism02 {
    public static void main(String[] args) {
        // Animal a = new Animal(); // 추상 클래스는 인스턴스를 생성할 수 없음.

        Cat c = new Cat();
        Dog d = new Dog();

        c.cry();
        d.cry();
    }
}

추상 메소드의 목적

• 추상 메소드가 포함된 클래스를 상속받는 자식 클래스가 반드시 추상 메소드를 구현하도록 하기 위함.

인터페이스 (Interface)

기본 설계도

• 자바에서 클래스들이 구현해야하는 동작을 지정하는 용도로 사용되는 추상 자료형
• interface 키워드를 이용하여 선언
• 다중 상속이 가능
• 상속하는 집한간에는 연관관계가 존재하지 않을 수 있음.
• 모든 멤버 변수는 public static final 이어야 하며, 이를 생략할 수 있음.
• 모든 메소드는 public abstract 이어야 하며, 이를 생략할 수 있음.
• 생략 시 컴파일러가 자동 추가

// 접근 지정자는 public 만 가능 , class 설계도 이기 때문에 존재 목적이 "공개"
public interface 인터페이스이름 {
    public static final 타입 상수이름 = 값;
    ...
    public abstract 메소드이름(매개변수목록);
    ...
}

• 인터페이스는 오로지 추상 메소드와 상수만을 포함할 수 있음.
• 직접 인스턴스를 생성할 수 없음.
• 객체를 생성할 수 없기 때문에, 생성자를 가질 수 없음.
• Java7 까지는 추상 메소드로만 선언이 가능 → Java8 부터는 디폴트 메소드와 정적 메소드 선언 가능

interface 도 Class, Enum, Annotation 처럼 ~.java 파일로 작성되고, ~.class 파일로 컴파일 된다.

인터페이스의 구현

class 클래스이름 extend 상위클래스이름 implements 인터페이스이름 { ... }

1. 단일 인터페이스 구현 클래스
2. 다중 인터페이스 구현 클래스
3. 익명 구현 객체

인터페이스의 역할

• 객체를 어떻게 구성해야 하는지 정리한 설계도
• 객체의 교환성(또는 다형성)을 높여줌.

인터페이스의 장점

• 대규모 프로젝트 개발 시 일관되고 정형화된 개발을 위한 표준화 가능
• 클래스의 작성과 인터페이스의 구현을 동시에 진행할 수 있으므로, 개발시간 단축
• 클래스와 클래스 간의 관계를 인터페이스로 연결하며, 클래스마다 독립적인 프로그래밍 가능

추상 클래스와 인터페이스의 차이점

공통점

1. 메소드의 선언만 있고, 구현 내용이 없음
2. 객체 ( 인스턴스 ) 생성 불가
3. 상속받은 자식 클래스에서 반드시 추상 메소드를 구현하도록 강제 됨.

차이점

1. 접근자
   1. 인터페이스에서 모든 변수는 public static final, 모든 메소드는 public abstract 임.
   2. 추상 클래스에서는 static이나 final이 아닌 필드를 가질 수 있고, public, protected, private 모두 가질 수 있음.
2. 다중 상속 여부
   1. 인터페이스를 구현하는 클래스는 다른 여러개 인터페이스를 함께 구현할 수 있음.
   2. 자바에서는 다중 상속을 지원하지 않기 때문에 여러 추상 클래스를 상속할 수 없음.
3. 사용 의도
   1. 추상 클래스는 객체들의 공통점을 찾아 추상화 시켜 놓은 것. 부모 클래스가 가진 기능들을 확장 구현해야할 경우 사용
   2. 인터페이스는 클래스와 별도로 구현 객체가 같은 동작을 한다는 것을 보장하기 위해 사용 공통된 기능
4. 적정한 사용 케이스
   1. 추상 클래스
      1. 관련성 높은 클래스 간에 코드를 공유하고 싶은 경우
      2. 추상 클래스를 상속 받을 클래스들이 공통으로 가지는 메소드와 필드가 많은 경우
      3. non-static, non-final 필드 선언이 필요한 경우
   2. 인터페이스
      1. 서로 관련성 없는 클래스들이 인터페이스를 구현하게 되는 경우
      2. 다중 상속을 허용하고 싶은 경우
      3. 특정 데이터 타입의 행동을 명시하고 싶은데, 어디서 그 행동이 구현되는지는 신경쓰지 않는 경우