Sue's devlog

[Kotlin] 코틀린 기초(1) : 변수, Null Safety, 타입

suaring — Sat, 21 Feb 2026 21:51:16 +0900

코틀린(Kotlin)이란?

코틀린은 JetBrains에서 2011년에 공개한 정적 타입 오픈소스 프로그래밍 언어이다.

Java와의 호환성 : JVM 위에서 동작하며 Java와 100% 호환된다. 기존 Java 프로젝트에 코틀린을 바로 도입하거나, Java 라이브러리를 그대로 가져와 사용할 수 있다.
간결한 코드 : Java의 장황한 코드(보일러플레이트)를 대폭 줄여, 적은 코드로 동일한 기능을 구현하여 생산성을 높인다.
안전성 (Null Safety) : NPE를 컴파일 시점에 방지하여 안정적인 개발이 가능
다양한 활용성 : 안드로이드 앱 개발, 백엔드 서버 개발(Spring 등), 멀티플랫폼 개발에 활용

변수

코틀린은 변수 선언 시 가변 여부(var / val)를 명확히 표시해주어야 한다.

fun main() {
    val num1 = 10L
    var num2 = 20L
}

val (Value) : 불변 변수로 초기화 후 값 변경이 불가능하다. (자바의 final)
var (Variable) : 가변 변수로 초기화 후 값 변경이 가능하다.

Tip : 모든 변수는 우선 val로 선언하고 꼭 필요한 경우에만 var로 변경하는 것이 클린 코드 유지에 유리하다.

✅ 타입 추론과 명시적 타입

코틀린은 자바와 다르게 타입을 지정해주지 않아도 컴파일 시점에 추론한다. 타입을 명시하고 싶다면 변수 뒤에 :타입을 붙여준다.

fun main() {
    val num1 = 10L // Long으로 추론
    val num2: Long = 10L // 명시적 타입 선언
}

만약 변수를 선언과 동시에 초기화하지 않는다면 타입 추론이 불가능하다. 이런 경우에는 타입을 명시해주어야 한다.

fun main() {
    val num1 // This variable must either have an explicit type or be initialized.
    val num2: Long
}

초기화되지 않은 변수는 사용할 수 없다.

fun main() {
    val num1: Long
    println(num1) // Variable 'num1' must be initialized.
}

✅ 기본 타입

자바에는 reference type(ex. Long)과 primitive type(ex. long)이 있다. reference type을 사용하여 연산하는 경우 boxing, unboxing이 일어나면서 불필요한 객체 생성이 발생한다. 그러나 코틀린에는 reference type과 primitive type에 구분이 없다. 코틀린에서는 실행 시점에 boxing, unboxing을 고려하지 않아도 되도록 가장 효율적인 방식으로 상황에 따라 처리한다.

fun main() {
    // 1. Primitive 타입으로 변환되는 경우 (최적화)
    val a: Long = 100L
    val b: Long = 200L
    val sum = a + b // 자바의 long + long 연산과 동일하게 동작

    // 2. Reference 타입(Wrapper)이 불가피한 경우
    val nullableSum: Long? = sum // null 허용 시 자바의 Long 객체로 생성
}

Null Safety : 코틀린의 핵심

코틀린의 가장 큰 특징은 Nullable과 Non-nullable 타입을 엄격히 구분한다는 점이다. 코틀린에서는 기본적으로 모든 변수는 null이 들어갈 수 없다. 만약 null이 들어올 수 있는 변수라면 선언 시 nullable 표시를 해주어야 한다.

fun main() {
    val num: Long? = 1_000L
}

⚠️ 주의할 점 코틀린이 알아서 최적화해주지만, Nullable(?) 타입을 남용하면 자바와 마찬가지로 내부적으로 Boxing이 발생하여 성능 저하가 생길 수 있다. 성능이 중요한 루프문 등에서는 최대한 non-nullable 타입을 사용하는 것이 좋다.

✅ Safe Call과 Elvis 연산자

별도로 null 체크를 하지 않는다면 nullable 인자의 경우 바로 함수를 호출할 수 없으므로 Safe Call 또는 Elvis 연산자를 사용해야 한다.

Safe Call(?.) : null이 아닐 때만 실행하고, null이면 전체 결과가 null이 된다.

val str: String? = "ABC"
println(str?.length)

Elvis 연산자(?:) : 앞의 연산 결과가 null이면 뒤에 지정한 기본값을 사용한다.

val str: String? = "ABC"
str?.length ?: 0

✅ null 아님 단언(!!)

정말 null이 아님이 확실할 떄만 사용한다. 만약 null일 경우 런타임에 NPE가 발생하므로 주의해야한다.

fun ignoreNull(str: String?): Boolean {
	return str!!.startsWith("A")
}

✅ 플랫폼 타입

자바 코드에서 @Nullable이나 @NotNull 어노테이션이 없어 코틀린이 null 가능성을 알 수 없는 타입으로,

자바와 코틀린을 함께 사용할 때 가장 주의해야 하는 부분이다. 코틀린에서 Non-nullable로 간주했다가 런타임에

NPE가 발생할 수 있다. 자바 라이브러리 사용 시 반드시 라이브러리 내부를 확인하고 널 가능성을 처리해야 한다.

타입

1. 기본 타입

Byte
Short
Int
Long
Double
Float
부호 없는 정수들

코틀린에서는 선언된 기본값을 보고 타입을 추론한다.

val num1 = 3 // Int
val num2 = 3L // Long
val num3 = 3.0f // Float
val num4 = 3.0 // Double

기본 타입 변환

코틀린은 자바와 달리 기본 타입간의 암시적 형변환을 허용하지 않는다.

val num1 = 4
// val num2: Long = num2 // Type mismatch
val num3: Long = num1.toLong() // 명시적 형변환

변수가 nullable이라면 적절한 처리가 필요하다.

val num1: Int? = 3
val num2: Long = num1?.toLong() ?: 0L

2. 타입 캐스팅

자바의 instanceof는 코틀린에서 is로 사용된다. is로 타입을 확인하면 스마트 캐스트가 일어나므로 별도의 형변환 코드가 필요 없다.

fun printNameIfPerson(obj: Any){
    if (obj is Person) {
        // obj는 Person 타입으로 간주됨 (스마트 캐스트)
        println(person.name)
    }
}

instanceof → is
!(instanceof) -> !is
(Person) obj -> obj as Person

nullable 변수에 대하여 타입 캐스팅 시, NPE를 방지하려면 as?를 붙여야 한다.

fun main() {
    printNameIfPerson(null)
}

fun printNameIfPerson(obj: Any?) {
	val person = obj as? Person // null이 아니면 형변환, null이면 null 반환
    println(person?.name)
}

3. 코틀린의 3가지 특이한 타입

Any
- 자바의 Object. 모든 객체의 최상위 타입 (Primitive Type 포함)
- Any 자체로는 null을 포함할 수 없음 (Any? 사용해야함)
- equals, hashCode, toString 존재
Unit
- 자바의 void와 동일한 역할
- void와 다르게 Unit은 그 자체로 타입 인자로 사용 가능하다
- 함수형 프로그래밍에서 Unit은 단 하나의 인스턴스만 갖는 타입을 의미. 즉, 코틀린의 Unit은 실제 존재하는 타입이라는 것을 표현
Nothing
- 함수가 정상적으로 종료되지 않음을 나타낸다. (무한 루프, 무조건 예외 발생)
- 실무에서 잘 쓰이지는 않음

4. String

코틀린은 자바와 달리 문자열 안에서 변수를 바로 사용할 수 있어 가독성이 뛰어나다.

val person = Person("수아", 100);
val str = "사람의 이름은 ${person.name}이고, 나이는 ${person.age}세 입니다."

val name = "수아"
println("이름: $name") // 중괄호 생략 가능

✅ Tip : 중괄호는 생략이 가능하지만 생략하지 않는 것이 가독성, 일괄 변환, 정규식 활용 측면에서 좋다.

여러 줄에 걸친 문자열을 작성해야 할 때

"""
	어쩌구저쩌구..
	${name}
""".trimIndent() // 인덴트 제거

문자열의 특정 문자 가져오기

val str = "ABC"
println(str[0])

연산자

대부분의 산술 연산자, 논리 연산자 등은 자바와 동일하지만, 몇가지 차이점이 있다.

✅ 동등성, 동일성

== : 동등성(값이 같은지) 비교. 내부적으로 equals() 호출 (자바의 equals)
=== : 동일성 비교. 주소값을 비교한다. (자바의 ==)

✅ 코틀린에 있는 특이한 연산자

in / !in : 컬렉션이나 범위에 포함되는지 확인
a..b : a부터 b까지의 범위 객체를 생성한다.
a[i] : a에서 특정 인덱스 i로 값을 가져온다.
a[i] = b : a의 특정 인덱스 i에 b를 넣는다.

✅ 연산자 오버로딩

코틀린에서는 객체마다 연산자를 직접 정의할 수 있다.

fun main() {
	val money1 = Money(1_000L)
	val money2 = Money(2_000L)
	println(money1 + money2) // 연산자 오버로딩
}

data class Money(
	val amount: Long
) {
	operator fun plus(other: Money): Money {
		return Money(this.amount + other.amount)	
	}
}

[Programmers Level 2] 올바른 괄호

suaring — Mon, 15 Aug 2022 01:26:09 +0900

문제

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

첫번째 시도

넘어온 괄호 문자열을 split으로 자른 후, 열린 괄호일 경우 스택에 push, 닫는 괄호일 경우 pop해서 스택이 비어있는지 여부를 반환하는 방법으로 시도했다.

import java.util.*;

class Solution {
    boolean solution(String s) {

        String[] temp = s.split("");
        Stack<String> stack = new Stack<>();
        
        // 닫는 괄호로 시작하거나 여는 괄호로 끝나면 false 반환
        if (temp[0].equals(")") || temp[temp.length-1].equals("(")) {
            return false;
        }
        
        for (int i = 0 ; i < temp.length ; i ++) {
            if (temp[i].equals("(")) { // 여는 괄호일 경우 stack에 push
                stack.push(temp[i]);
            } else { // 닫는 괄호일 경우 pop
                
                if (stack.isEmpty()) {
                    return false;
                }
                
                stack.pop();    
                
            }
        }

        return stack.isEmpty();
    }

결과

효율성 점수 빵점..

두번째 시도

split 하는 과정을 생략하고 String의 charAt 메서드를 사용해서 괄호를 비교하는 방법을 사용했다. split 메서드 실행 시 문자열을 분리하고, 배열에 삽입하는 과정까지 들어가기 때문에 시간복잡도는 O(n^2)이 되어서 그런 것 같다!

그리고 for문에 들어가기 전 문자열 맨 앞의 괄호가 닫힌 괄호일 경우, 문자열 맨 뒤의 괄호가 열린 괄호일 경우 바로 false를 리턴하는 방법이 효율성을 높여줄 줄 알았는데 아니었다..^^ 비교 해보니까 효율성 테스트 시간에 + 3 ~ 4ms 로 나와서 해당 코드는 제거했다.

import java.util.*;

class Solution {
    boolean solution(String s) {

        // split으로 String 배열 사용 시 효율성 0점 > charAt() 사용

        Stack<Character> stack = new Stack<>();
        
        for (int i = 0 ; i < s.length() ; i ++) {
            
            if (s.charAt(i) == '(') { // 여는 괄호일 경우 stack에 push
                stack.push(s.charAt(i));
            } else { // 닫는 괄호일 경우 pop
                
                if (stack.isEmpty()) { // stack에 열린 괄호가 없으면 바로 false 반환
                    return false;
                }
                
                stack.pop();    
                
            }
        }

        return stack.isEmpty();
    }
}

결과

[Programmers Level 2] 전화번호 목록

suaring — Sat, 13 Aug 2022 15:27:45 +0900

문제

프로그래머스

programmers.co.kr

첫번째 시도

해시를 사용할 방법이 떠오르지 않아서 일단 배열의 반복문을 사용해서 시도해봤다.

import java.util.*;

class Solution {
    public boolean solution(String[] phone_book) {
        
        /*
            1. 길이 순으로 정렬
            2. 가장 짧은 길이의 번호를 기준으로 각 문자열의 substring을 비교
            3. 루프를 한번 돌고, 다음 인덱스로 넘어가서 반복
        */
        
        // 문자열 길이 순으로 정렬, 짧은 문자열이 긴 문자열로 시작하는 경우는 없음
        Arrays.sort(phone_book, new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return s1.length() - s2.length();
            }
        });
        
        // 가장 짧은 길이의 번호를 기준으로 각 문자열의 substring을 비교
        for (int i = 0 ; i < phone_book.length-1 ; i ++) {
            
            // 현재 인덱스에 있는 문자열 저장
            String s = phone_book[i];
            
            for (int j = i+1 ; j < phone_book.length ; j ++) {
                
                // 접두어가 있으면 바로 false 반환
                if (phone_book[j].startsWith(s)) {
                    return false;
                }
            }
        }
        
        // for문 다 돌고나서도 접두어가 없으면 true 반환
        return true;
        
        
    }
}

결과

효율성 테스트 4개 중 2개 빼고 통과..!

3, 4번에서 계속 시간초과 뜬다ㅡ.ㅡ

힌트를 찾아본 결과 for문을 한번만 쓰고, 비교도 바로 뒤 문자열과만 비교하면 된다고 한다고 해서 다시 시도!

두번째 시도

힌트 참고해서 다시 풀었음! 이중 for문을 쓰던걸 하나로 줄여서 시간 복잡도가 O(n^2)에서 O(n)으로 줄었따

import java.util.*;

class Solution {
    public boolean solution(String[] phone_book) {
        
        /*
            1. 문자열 배열 정렬 (문자열 > 길이 순으로 정렬)
            2. 뒤의 문자열이 앞의 문자열로 시작하면 바로 false 반환
            3. 루프를 한번 돌고, 다음 인덱스로 넘어가서 반복
        */
        
        // 문자열 배열 정렬
        Arrays.sort(phone_book);
        
        // System.out.println(Arrays.toString(phone_book));
        
        // 가장 짧은 길이의 번호를 기준으로 각 문자열의 substring을 비교
        for (int i = 0 ; i < phone_book.length-1 ; i ++) {
            
            // 현재 인덱스에 있는 문자열 저장
            String s = phone_book[i];
            
            if (phone_book[i+1].startsWith(phone_book[i])){
                return false;
            }
        }
        
        return true;
        
    }
}

문자열 배열을 정렬을 이해하면 쉽게 풀 수 있다.

정렬 시 문자열 > 문자열 길이 순으로 정렬되기 때문에 만약 앞의 문자열을 포함하는 문자열이 있으면, 해당 문자열 바로 뒤에 위치하게 된다!

결과

AWS EC2 스프링 부트 프로젝트 gradlew test 오류 해결

suaring — Thu, 16 Jun 2022 18:41:46 +0900

상황

스프링부트로 작성한 프로젝트를 배포하기 위해 ec2 서버에 올리는 과정에서 github에 push하고 clone까지는 되었으나 ./gradlew test 입력 시 오류가 발생했다.. 에러 뜬 상황을 자세히 보니 constructor, getter 부분에서 오류가 나길래 lombok 문제인 것 같았다. (사실 에러 메세지를 제대로 확인하지 않았을 때는 자바를 인식하지 못하는 줄 알고 환경변수 설정을 했지만 오히려 다른 에러가 발생했다..ㅎㅎㅎ)

해결

스프링 부트 프로젝트에 lombok 플러그인을 설치했기 때문에 기존 build.gradle에는 implementation lombok만 해주었었다.

implementation('org.projectlombok:lombok')

lombok은 컴파일 시에만 필요하기 때문에 implementation -> compileOnly로 수정하고, 플러그인의 역할을 해주는annotationProcessor 설정을 추가했다. test에서도 문제가 발생할 수 있으니 관련 설정을 모두 추가했다.

compileOnly('org.projectlombok:lombok')
annotationProcessor('org.projectlombok:lombok')
testCompileOnly('org.projectlombok:lombok')
testAnnotationProcessor('org.projectlombok:lombok')

build.gradle 파일을 수정하고 github에 push한 뒤 putty에서 pull해서 다시 실행하니 테스트 성공!

참고

[Spring] MVC 1편 (10) - 실용적인 스프링 MVC

suaring — Thu, 31 Mar 2022 20:52:05 +0900

@RequestMapping

스프링에서는 애노테이션을 활용한 매우 유연하고 실용적인 컨트롤러를 사용할 수 있다. 가장 우선순위가 높은 핸들러 매핑과 핸들러 어댑터는 애노테이션 기반의 컨트롤러를 지원하는 각각 RequestMappingHandlerMapping과 RequestMappingAdapter이다. 실무에서는 이 방식의 컨트롤러를 사용한다!

회원 등록 폼

@Controller
public class SpringMemberFormControllerV1 {

   @RequestMapping("/springmvc/v1/members/new-form")
    public ModelAndView process() {
  	return new ModelAndView("new-form");  
    }
}

@Controller : 스프링이 자동으로 스프링 빈으로 등록하고, 스프링 MVC에서 애노테이션 기반 컨트롤러로 인식한다.
@RequestMapping : 요청 정보를 매핑한다. 해당 URL이 호출되면 이 메서드가 호출된다.
ModelAndView : 모델과 뷰 정보를 담아서 반환한다.

컨트롤러 통합

@RequestMapping은 메서드 단위에 적용되기 때문에 하나의 클래스에 각 컨트롤러의 메서드를 배치할 수 있다.

MemberController

@Controller
@RequestMapping("/springmvc/v2/members") // 중복을 줄일 수 있음!
public class SpringMemberControllerV2 {

    private MemberRepository memberRepository = MemberRepository.getInstance();

    @RequestMapping("/new-form")
    public ModelAndView newForm() { // 반환 타입 ModelAndView
        return new ModelAndView("new-form");
    }

    @RequestMapping("/save")
    public ModelAndView save(HttpServletRequest request, HttpServletResponse response) {

        String username = request.getParameter("username");
        int age = Integer.parseInt(request.getParameter("age"));

        Member member = new Member(username, age);
        memberRepository.save(member);

        ModelAndView mv = new ModelAndView("save-result");
        mv.addObject("member",member);
        return mv;
    }

    @RequestMapping
    public ModelAndView members() {

        List<Member> members = memberRepository.findAll();
        ModelAndView mv = new ModelAndView("members");
        mv.addObject("members", members); // Map을 사용하는 것보다 간단하게 값을 넘겨줄 수 있음

        return mv;
    }
}

중복되는 뷰 이름은 클래스 레벨의 @RequestMapping에 두어 중복을 줄일 수 있다.

실용적인 방식

실무에서 주로 사용하는 방법이다.

@Controller
@RequestMapping(value = "/springmvc/v3/members")
public class SpringMemberControllerV3 {

    private MemberRepository memberRepository = MemberRepository.getInstance();

    @GetMapping("/new-form") // 데이터 단순 조회 -> GET
    public String newForm() { // String으로 반환하면 뷰 이름으로 인식됨
        return "new-form";
    }

    @PostMapping("/save") // 데이터의 변경 발생 -> POST
    public String save(
            @RequestParam("username") String username, // 파라미터를 직접 받을 수 있음
            @RequestParam("age") int age, // 타입 변환까지 자동으로 해줌
            Model model) {

        Member member = new Member(username, age);
        memberRepository.save(member);

        model.addAttribute("member",member);
        return "save-result";
    }

    @GetMapping
    public String members(Model model) {

        List<Member> members = memberRepository.findAll();
        model.addAttribute("members", members);
        return "members";
    }
}

Model 파라미터 : Model을 메서드의 파라미터로 받을 수 있다. 각 메서드는 데이터를 addAttribute() 메서드를 사용해서 Model에 저장한다.
ViewName : 각 메서드를 실행하고 ModelView를 반환하는 것이 아닌, 뷰의 논리 이름을 반환
@ReqeustParam : 매개변수로 지정한 이름의 요청 파라미터를 변수로 가져온다. == request.getParameter("username")
@GetMapping, @PostMapping : URL을 매핑하는 동시에 HTTP 메서드도 함께 구분할 수 있다.

강의 링크

스프링 MVC 1편 - 백엔드 웹 개발 핵심 기술 - 인프런 | 강의

웹 애플리케이션을 개발할 때 필요한 모든 웹 기술을 기초부터 이해하고, 완성할 수 있습니다. 스프링 MVC의 핵심 원리와 구조를 이해하고, 더 깊이있는 백엔드 개발자로 성장할 수 있습니다., -

www.inflearn.com

[Spring] MVC 1편 (9) - 스프링 MVC 프레임워크 구조

suaring — Thu, 31 Mar 2022 20:26:45 +0900

스프링 MVC 구조

✅ 동작 순서

핸들러 조회: 핸들러 매핑을 통해 요청 URL에 매핑된 핸들러를 조회한다.
핸들러 어댑터 조회: 핸들러를 실행할 수 있는 핸들러 어댑터를 조회한다.
핸들러 어댑터 실행: 핸들러 어댑터를 실행한다.
핸들러 실행: 핸들러 어댑터가 실제 핸들러를 실행한다.
ModelAndView 반환: 핸들러 어댑터는 핸들러가 반환하는 정보를 ModelAndView로 변환해서 반환한다.
viewResolver 호출: 뷰 리졸버를 찾고 실행한다.
View 반환 : 뷰 리졸버가 뷰의 논리 이름을 물리 이름으로 바꾸고, 렌더링 역할을 담당하는 뷰 객체를 반환한다.
뷰 렌더링 : 뷰를 통해 뷰를 렌더링한다.

간단한 핸들러 매핑과 핸들러 어댑터 사용해보기

OldController

@Component("/spirngmvc/old-controller")
public class OldController implements Controller {

    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        System.out.println("OldController.handleRequest");
        return null;
    }
}

ModelAndView를 반환하는 스프링의 과거 버전 인터페이스이다.
이 컨트롤러는 /spirngmvc/old-controller라는 이름의 스프링 빈으로 등록되었다.

핸들러가 호출되기 위해서는 두가지가 필요하다. → 핸들러 매핑, 핸들러 어댑터

✅ 스프링 부트가 자동 등록하는 핸들러 매핑과 핸들러 어댑터

HandlerMapping

0 = RequestMappingHandlerMapping // 애노테이션 기반의 컨트롤러인 @RequestMapping에서 사용
1 = BeanNameUrlHandlerMapping // 스프링 빈으로 찾을 때 사용

HandlerAdapter

0 = RequestMappingHandlerAdapter // 애노테이션 기반의 컨트롤러인 @RequestMapping에서 사용
1 = HttpRequestHandlerAdapter // HttpRequestHandler 처리
2 = SimpleControllerHandlerAdapter // Controller 인터페이스(애노테이션X, 과거에 사용) 처리

✅ 과정

1️⃣ 핸들러 매핑으로 핸들러 조회

HandlerMapping을 순서대로 실행해서 핸들러를 찾는다.
빈 이름으로 핸들러를 찾아주는 BeanNameUrlHandlerMapping이 실행되고, 핸들러인 OldController를 반환한다.

2️⃣ 핸들러 어댑터 조회

HandlerAdapter의 supports()를 순서대로 호출한다.
SimpleControllerHandlerAdapter가 Controller 인터페이스를 지원하므로 반환된다.

3️⃣ 핸들러 어댑터 실행

- Dispatcher 서블릿이 조회한 SimpleControllerHandlerAdapter를 실행하면서 핸들러 정보도 함께 넘겨준다.

- 어댑터는 핸들러를 내부에서 실행하고, 결과를 반환한다.

간단한 뷰와 뷰 리졸버 사용해보기

OldController

return new ModelAndView("new-form");

View를 사용할 수 있도록 코드 추가

✅ ViewResolver 설정 정보

spring.mvc.view.prefix=/WEB-INF/views/
spring.mvc.view.suffix=.jsp

application.properties에 설정 정보를 추가한다.
스프링 부트는 InternalResourceViewResolver를 사용하는데 이때 이 설정 정보를 사용해서 뷰 객체를 생성한다.

✅ 스프링 부트가 자동 등록하는 뷰 리졸버

ViewResolver

1 = BeanNameViewResolver // 빈 이름으로 뷰를 찾아서 반환한다. (예: 엑셀 파일 생성 기능에 사용)
2 = InternalResourceViewResolver // JSP를 처리할 수 있는 뷰를 반환한다.

✅ 과정

1️⃣ 핸들러 어댑터 호출

핸들러 어댑터를 통해 new-form이라는 논리 뷰 이름을 획득한다.

2️⃣ ViewResolver 호출

new-form이라는 뷰 이름으로 viewResolver를 순서대로 호출한다.
new-form이라는 이름으로 등록된 스프링 빈이 없으므로 InternalResourceViewResolver가 호출된다.

3️⃣ InternalResourceViewResolver

InternalResourceView를 반환한다.

4️⃣ 뷰 렌더링

view.render()가 호출되고 InternalResourceView는 forward()를 사용해서 JSP를 실행한다.

강의 링크

스프링 MVC 1편 - 백엔드 웹 개발 핵심 기술 - 인프런 | 강의

www.inflearn.com

[Spring] MVC 1편 (8) - MVC 프레임워크 만들기 v4,v5

suaring — Thu, 31 Mar 2022 19:37:58 +0900

v1, v2, v3

[Spring] MVC 1편 (7) - MVC 프레임워크 만들기 v1, v2, v3

프론트 컨트롤러 ✅ 프론트 컨트롤러 도입 전 프론트 컨트롤러 도입 전에는 각 컨트롤러에서 공통 로직을 구현해줘야 했다. ✅ 프론트 컨트롤러 도입 후 모든 요청 메세지는 공통 로직이 구

suaring.tistory.com

MVC 프레임워크 만들기

✅ v4 - 단순하고 실용적인 컨트롤러

v3 컨트롤러는 서블릿의 종속성을 제거하고 뷰 경로의 중복을 제거하여 잘 설계된 컨트롤러이다. 그러나 개발자 입장에서 항상 컨트롤러에서 ModelView 객체를 생성해서 반환해야 하는 부분이 번거롭다. 이번 버전에서는 조금 더 실용적인 방법으로 리팩토링 해본다.

기본적인 구조는 v3와 같지만, 각 컨트롤러는 이제 ModelView를 반환하지 않고 viewName 즉, 뷰의 논리 이름만 반환한다.

ControllerV4 인터페이스

public interface ControllerV4 {

 String process(Map<String, String> paramMap, Map<String, Object> model);
}

각 컨트롤러는 뷰의 이름만 반환하기 때문에 반환타입을 String으로 설정한다.
또 각 컨트롤러가 객체를 저장할 model 맵을 파라미터로 전달한다.

회원 저장 컨트롤러

public class MemberSaveControllerV4 implements ControllerV4 {

    private MemberRepository memberRepository = MemberRepository.getInstance();

    @Override
    public String process(Map<String, String> paramMap, Map<String, Object> model) {

        String username = paramMap.get("username");
        int age = Integer.parseInt(paramMap.get("age"));

        Member member = new Member(username, age);
        memberRepository.save(member);

        model.put("member", member);
        return "save-result";
    }
}

모델이 파라미터로 전달되기 때문에, 모델을 직접 생성하지 않아도 된다.
파라미터로 넘어온 모델에 값을 넣어주고 뷰 이름만 반환해주면 된다.

FrontControllerV4

Map<String, String> paramMap = createParamMap(request);
Map<String, Object> model = new HashMap<>(); //추가

String viewName = controller.process(paramMap, model);

MyView view = viewResolver(viewName);
view.render(model, request, response);

모델 객체를 프론트 컨트롤러에서 생성해서 넘겨준다.
컨트롤러의 process() 메서드를 실행하고, 반환받은 viewName으로 논리 이름을 물리 이름으로 바꾼 MyView 객체를 생성해서 render()를 호출한다.

✅ v5 - 유연한 컨트롤러

만약 v3, v4 컨트롤러를 모두 사용하고 싶다면? 우리가 개발한 프론트 컨트롤러는 한가지 방식의 컨트롤러 인터페이스만 사용할 수 있다. 여기에 어댑터 패턴을 적용하면 다양한 방식의 컨트롤러를 사용할 수 있게 된다.

프론트 컨트롤러는 핸들러(컨트롤러) 매핑 정보에서 요청 URL를 기반으로 핸들러를 조회한다. 다음으로 조회한 핸들러를 지원할 수 있는 핸들러 어댑터를 핸들러 어댑터 목록에서 찾는다. 이제 프론트 컨트롤러는 컨트롤러를 직접 호출하지 않고, 핸들러 어댑터가 대신 호출해준다. 프론트 컨트롤러는 핸들러 어댑터가 반환해준 넘어온 ModelView 객체를 가지고 논리 이름을 물리 이름으로 바꾸어 렌더링해주면 된다.

MyHandlerAdapter

public interface MyHandlerAdapter {

    boolean supports(Object handler);

    ModelView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws IOException, ServletException;
}

boolean supports(Object handler)
- 어댑터가 해당 컨트롤러를 처리할 수 있으면 true를 반환한다.
ModelView handler(HttpServletRequest request, HttpServletResponse response, Object handler)
- 어댑터는 컨트롤러를 호출하고 그 결과로 ModelView를 반환한다.
- 컨트롤러가 ModelView를 반환하지 않는 경우, 어댑터가 직접 생성해서 반환한다.

ControllerV3HandlerAdapter

public class ControllerV3HandlerAdapter implements MyHandlerAdapter {

    @Override
    public boolean supports(Object handler) {
        return (handler instanceof ControllerV3); // ControllerV3의 구현체일 경우 true 반환
    }

    @Override
    public ModelView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws IOException, ServletException {

        ControllerV3 controller = (ControllerV3) handler; // supports 메서드로 확인해주고 handle을 호출하기 때문에 캐스팅해도 괜찮음

        Map<String, String> paramMap = createParamMap(request);
        ModelView mv = controller.process(paramMap);
        return mv;
    }

    private Map<String, String> createParamMap(HttpServletRequest request) {

        Map<String, String> paramMap = new HashMap<>();
        request.getParameterNames().asIterator()
                .forEachRemaining(paramName -> paramMap.put(paramName, request.getParameter(paramName)));
        return paramMap;
    }
}

ModelView를 리턴하는 ControllerV3를 지원하는 핸들러 어댑터이다.
먼저 매개변수로 들어오는 핸들러를 처리할 수 있는 핸들러 어댑터인지 검사한다. (ControllerV3의 구현체인지 확인)
처리할 있는 핸들러라면 HTTP 요청으로부터 paramMap을 생성하고, 이것을 컨트롤러에게 넘겨주면서 컨트롤러를 실행한다.
컨트롤러의 process를 호출한 후 반환값인 ModelView를 프론트 컨트롤러에 전달한다.

ControllerV4HandlerAdapter

public class ControllerV4HandlerAdapter implements MyHandlerAdapter {

    @Override
    public boolean supports(Object handler) {
        return (handler instanceof ControllerV4);
    }

    @Override
    public ModelView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws IOException, ServletException {

        ControllerV4 controller = (ControllerV4) handler;
        Map<String, String> paramMap = createParamMap(request);
        HashMap<String, Object> model = new HashMap<>();

        String viewName = controller.process(paramMap, model);

        ModelView mv = new ModelView(viewName);
        mv.setModel(model);

        return mv;
    }

    private Map<String, String> createParamMap(HttpServletRequest request) {

        Map<String, String> paramMap = new HashMap<>();
        request.getParameterNames().asIterator()
                .forEachRemaining(paramName -> paramMap.put(paramName, request.getParameter(paramName)));
        return paramMap;
    }
}

FrontControllerV5 - 핸들러 매핑 정보, 핸들러 어댑터 목록

public class FrontControllerServletV5 extends HttpServlet {

   // private Map<String, ControllerV4> controllerMap = new HashMap<>(); 기존 컨트롤러 맵
    private final Map<String, Object> handlerMappingMap = new HashMap<>(); // Map의 value 타입을 Object로 설정해서 모든 컨트롤러 지원
    private final List<MyHandlerAdapter> handlerAdapters = new ArrayList<>();

    public FrontControllerServletV5() {
        initHandlerMappingMap();
        initHandlerAdapters();
    }

    private void initHandlerMappingMap() {
        handlerMappingMap.put("/front-controller/v5/v3/members/new-form", new MemberFormControllerV3());
        handlerMappingMap.put("/front-controller/v5/v3/members/save", new MemberSaveControllerV3());
        handlerMappingMap.put("/front-controller/v5/v3/members", new MemberListControllerV3());
        
        handlerMappingMap.put("/front-controller/v5/v4/members/new-form", new MemberFormControllerV4());
        handlerMappingMap.put("/front-controller/v5/v4/members/save", new MemberSaveControllerV4());
        handlerMappingMap.put("/front-controller/v5/v4/members", new MemberListControllerV4());
    }

    private void initHandlerAdapters() {
        handlerAdapters.add(new ControllerV3HandlerAdapter());
        handlerAdapters.add(new ControllerV4HandlerAdapter());
    }

}

먼저 기존처럼 핸들러 매핑 맵을 생성한다. 이때 특정 Controller 인터페이스로 Value 값을 설정하지 않고, Object로 설정해서 모든 컨트롤러가 Value로 들어올 수 있다.
핸들러 어댑터를 담아놓을 리스트를 생성한다.
FrontController는 생성될 때 handlerMappingMap과 handlerAdapters를 가지고 있다.

FrontControllerV5 - 메서드

@Override
protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    Object handler = getHandler(request);

    if (handler == null) {
        response.setStatus(HttpServletResponse.SC_NOT_FOUND);
        return;
    }

    MyHandlerAdapter adapter = getHandlerAdapter(handler);
    ModelView mv = adapter.handle(request, response, handler);

    String viewName = mv.getViewName();
    MyView view = viewResolver(viewName);
    view.render(mv.getModel(), request, response);

}

private Object getHandler(HttpServletRequest request) { // 매핑 정보를 사용해서 핸들러를 찾음
    String requestURI = request.getRequestURI();
    return handlerMappingMap.get(requestURI);
}

private MyHandlerAdapter getHandlerAdapter(Object handler) { // 리스트에서 for문으로 handler를 support하는 어댑터를 찾음
    for (MyHandlerAdapter adapter : handlerAdapters) {
        if (adapter.supports(handler)) {
          return adapter;
        }
    }
    throw new IllegalArgumentException("handler adapter를 찾을 수 없습니다. handler = " + handler);
}

private MyView viewResolver(String viewName) {
    return new MyView("/WEB-INF/views/" + viewName + ".jsp");
}

service() 메서드가 실행되면 request로 들어온 URL를 기반으로 핸들러 매핑 맵에서 컨트롤러를 찾는다.
어댑터 목록에서 루프를 돌려 핸들러를 지원하는지 확인하고, 지원하는 어댑터를 가져온다.
어댑터의 handle() 메서드를 호출하고 반환된 ModelView를 렌더링한다.

→ 이제 어댑터를 사용하기 때문에 컨트롤러 뿐만 아니라, 어댑터가 지원하기만 하면 어떤 것이든 URL에 매핑하여 사용할 수 있다! (확장성 up)

강의 링크

스프링 MVC 1편 - 백엔드 웹 개발 핵심 기술 - 인프런 | 강의

www.inflearn.com

[Spring] MVC 1편 (7) - MVC 프레임워크 만들기 v1, v2, v3

suaring — Tue, 29 Mar 2022 23:32:19 +0900

프론트 컨트롤러

✅ 프론트 컨트롤러 도입 전

프론트 컨트롤러 도입 전에는 각 컨트롤러에서 공통 로직을 구현해줘야 했다.

✅ 프론트 컨트롤러 도입 후

모든 요청 메세지는 공통 로직이 구현되어 있는 프론트 컨트롤러로 들어온다.
프론트 컨트롤러는 요청에 맞는 컨트롤러를 찾아 호출해준다.
프론트 컨트롤러에서 요청 메세지를 매핑 시켜주면, 나머지 컨트롤러는 서블릿을 사용하지 않아도 된다.

스프링 웹 MVC의 핵심도 FrontController

→ 스프링 웹 MVC의 DispatcherServlet이 FrontController 패턴으로 구현되어 있음!

MVC 프레임워크 직접 만들어보기

✅ v1 - 프론트 컨트롤러 도입

HTTP 요청이 들어오면 프론트 컨트롤러는 요청의 URL을 바탕으로 매핑 정보에서 요청 URL과 맞는 컨트롤러를 찾아 호출한다. 각 컨트롤러는 dispatcher.forward()를 사용해서 뷰를 호출한다.

ControllerV1 인터페이스

public interface ControllerV1 {

    void process(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException;
}

각 컨트롤러는 이 인터페이스를 구현한다.
프론트 컨트롤러는 이 인터페이스의 process() 메서드를 호출하여 로직의 일관성을 가져갈 수 있다.

FrontControllerV1

@WebServlet(name = "frontControllerServletV1", urlPatterns = "/front-controller/v1/*") // v1의 어떤 url이 들어와도 프론트 컨트롤러 서블릿이 무조건 먼저 호출
public class FrontControllerServletV1 extends HttpServlet {

    private Map<String, ControllerV1> controllerMap = new HashMap<>();

    // 서블릿이 생성될 때 url의 매핑 정보를 가지고 있음 (Map의 형태: key=url, value=각 컨트롤러 구현 객체)
    public FrontControllerServletV1() {
        controllerMap.put("/front-controller/v1/members/new-form", new MemberFormControllerV1());
        controllerMap.put("/front-controller/v1/members/save", new MemberSaveControllerV1());
        controllerMap.put("/front-controller/v1/members", new MemberListControllerV1());
    }

    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("FrontControllerServletV1.service"); // 실제로 실행되는지 확인하기 위해서는 로그 찍어보기

        String requestURI = request.getRequestURI();// 요청으로 들어오는 URI를 그대로 받을 수 있음

        ControllerV1 controller = controllerMap.get(requestURI); // 다형성 활용 (인터페이스 타입으로 컨트롤러 가져옴)
        if(controller == null) { // 들어온 URI가 없을 때 예외 처리
             response.setStatus(HttpServletResponse.SC_NOT_FOUND);
             return;
        }

	// 인터페이스의 메서드 호출
        controller.process(request, response);
    }
}

urlPatterns를 "/front-controller/v1/*"로 설정하면 /front-controller/v1를 포함한 모든 하위 요청은 이 서블릿으로 들어온다.
controllerMap에는 각 컨트롤러의 url 매핑 정보를 저장하고, 이는 서블릿이 생성될 때 가지고 있는다.
request.getRequestURI()로 요청으로 들어온 URI를 key로 사용해 controllerMap에서 컨트롤러를 인터페이스 타입으로 가져온다. (다형성)
만약 컨트롤러 중 요청 URI와 맞는 컨트롤러가 없으면 NOT_FOUND 상태 코드를 반환한다.
컨트롤러가 있으면 컨트롤러에 공통으로 구현되어 있는 process() 메서드를 호출한다.

→ 프론트 컨트롤러를 도입했고, Controller의 인터페이스를 도입해서 더 확장성 있고 일관적으로 로직을 처리할 수 있게 되었다!

✅ v2 - View 분리

String viewPath = "/WEB-INF/views/new-form.jsp";
RequestDispatcher dispatcher = request.getRequestDispatcher(viewPath);
dispatcher.forward(request, response);

모든 컨트롤러에서 뷰로 이동하는 부분에 중복이 있다.

기존에는 컨트롤러에서 직접 JSP를 forward 해주었지만, 이제 Controller는 MyView 객체를 생성해서 FrontController에게 넘겨주기만 하면 FrontController에서 뷰로 이동하는 로직을 실행한다.

MyView

public class MyView {

    private String viewPath;

    public MyView(String viewPath) {
        this.viewPath = viewPath;
    }

    // 서블릿에서 jsp로 이동해서 렌더링 되도록 동작
    public void render(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        RequestDispatcher dispatcher = request.getRequestDispatcher(viewPath);
        dispatcher.forward(request, response);
    }
}

MyView 클래스에는 뷰의 경로를 저장할 변수와 JSP를 forward해주는 render() 메서드를 구현한다.

ControllerV2 인터페이스

public interface ControllerV2 {

    MyView process(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException;
}

이제 각 컨트롤러는 로직을 수행하고 MyView 객체를 생성해서 반환한다. 이때 각 뷰의 경로를 입력한다.

FrontControllerV2

@Override
protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

// 나머지 부분 v1과 동일

    MyView myView = controller.process(request, response);
    myView.render(request, response);
}

Map에서 가져온 컨트롤러의 호출 결과로 MyView 객체를 받는다. view.render()를 호출하면 각 컨트롤러에 맞는 forward 로직이 수행된다.

→ 이제 각 컨트롤러가 직접 JSP를 forward 하지 않고, 프론트 컨트롤러에서 처리하기 때문에 각 컨트롤러에 중복으로 들어갔던 forward 코드를 작성해주지 않아도 된다.

✅ v3 - 모델 추가

서블릿 종속성 제거 : 컨트롤러 입장에서 request와 response 객체가 필요하지 않다. 요청 파라미터 정보를 자바의 Map으로 대신 넘기도록 하면 컨트롤러는 서블릿 기술을 몰라도 된다.
뷰 이름 중복 제거 : 경로를 지정하는 부분과 파일의 확장자 부분을 작성하는 부분이 중복된다. 각 컨트롤러는 논리 이름만 반환하도록 하고, 물리 위치의 이름은 프론트 컨트롤러에서 처리하도록 하자. (유지보수 편리)

지금까지 컨트롤러에서 서블릿에 종속적인 HttpServletRequest를 사용했고, Model도 request.setAttribute()를 통해 데이터를 보관하고 뷰에 전달했다. 이번 버전에서는 서블릿의 종속성을 제거하기 위해 Model을 직접 만들고, 뷰의 논리 이름을 물리 이름으로 바꿔주는 객체도 생성해볼 것이다.

ModelView

public class ModelView {

    private String viewName;
    private Map<String, Object> model = new HashMap<>(); // key=이름, value=객체

    public ModelView(String viewName) {
        this.viewName = viewName;
    }

    public String getViewName() {
        return viewName;
    }

    public void setViewName(String viewName) {
        this.viewName = viewName;
    }

    public Map<String, Object> getModel() {
        return model;
    }

    public void setModel(Map<String, Object> model) {
        this.model = model;
    }
}

뷰의 이름과 뷰를 렌더링할 때 필요한 model 객체를 가지고 있다.

ControllerV3

public interface ControllerV3 {

    ModelView process(Map<String, String> paramMap);
}

이제 컨트롤러는 서블릿 기술을 전혀 사용하지 않는다. > 구현 매우 단순, 테스트하기도 쉬워짐
HttpServletRequest가 제공하는 파라미터는 프론트 컨트롤러에서 paramMap에 담아준다.
각 컨트롤러는 로직 수행 후 ModelView를 반환한다.

회원 저장 컨트롤러

public class MemberSaveControllerV3 implements ControllerV3 {

    private MemberRepository memberRepository = MemberRepository.getInstance();

    @Override
    public ModelView process(Map<String, String> paramMap) {

        // 기존 방식이었던 getParameter() 메서드를 사용하는 부분은 front controller에서 처리해줌
        String username = paramMap.get("username");
        int age = Integer.parseInt(paramMap.get("age"));

        Member member = new Member(username, age);
        memberRepository.save(member);

        ModelView mv = new ModelView("save-result");
        mv.getModel().put("member", member);
        return mv;
    }
}

이제 컨트롤러에서는 paramMap에서 요청 파라미터의 값을 꺼내서 비즈니스 로직을 수행한다.
컨트롤러에서 ModelView 객체를 생성하는데, 이때 생성자의 매개변수로 논리 이름을 입력한다.
ModelView 객체의 model에 뷰를 렌더링 할 때 필요한 객체를 담고 반환한다.

FrontControllerV3

@Override
protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

    // 생략

    Map<String, String> paramMap = createParamMap(request);
    // request, response 대신 paraMap을 넘겨줘야 함
    ModelView mv = controller.process(paramMap);

    String viewName = mv.getViewName();

    MyView view = viewResolver(viewName);// 논리 이름을 물리 이름으로 바꿔줌
    view.render(mv.getModel(), request, response);

} // service

private MyView viewResolver(String viewName) {
    return new MyView("/WEB-INF/views/" + viewName + ".jsp");
}

private Map<String, String> createParamMap(HttpServletRequest request) {

    Map<String, String> paramMap = new HashMap<>();

    request.getParameterNames().asIterator()
            .forEachRemaining(paramName -> paramMap.put(paramName, request.getParameter(paramName)));

    return paramMap;
}

HttpServletRequest에서 파라미터 정보를 꺼내서 paramMap에 넣어둔다.
이때 생성된 paramMap은 컨트롤러가 호출될 때 전달된다.
viewResolver 메서드는 논리 이름을 받아 물리 뷰 경로로 변환하고, 실제 물리 경로가 있는 MyView 객체를 반환한다.
render()를 수행하게 되면 뷰 렌더링할 때 필요한 데이터가 담긴 모델 Map도 넘겨줘야 한다.

MyView

public class MyView {
	
    // ...
	
    public void render(Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException{
        modelToRequestAttribute(model, request);
        RequestDispatcher dispatcher = request.getRequestDispatcher(viewPath);
        dispatcher.forward(request, response);
    }

    // model에 있는 데이터를 request의 attribute로 설정 -> JSP 사용 시 필요
    private void modelToRequestAttribute(Map<String, Object> model, HttpServletRequest request) {
        model.forEach((key, value) -> request.setAttribute(key,value));
    }
}

MyView에서는 넘어온 모델 Map을 가지고 각 데이터에 대해 request.setAttribute를 수행한다.

강의 링크

스프링 MVC 1편 - 백엔드 웹 개발 핵심 기술 - 인프런 | 강의

www.inflearn.com

[Spring] MVC 1편 (6) - MVC 패턴 적용

suaring — Tue, 29 Mar 2022 21:14:58 +0900

MVC 패턴 사용 이유?

너무 많은 역할 : 하나의 파일에서 비즈니스 로직을 수행하고 뷰 렌더링까지 처리하면 유지보수가 어렵다.
변경의 라이프 사이클 : 비즈니스 로직과 뷰 렌더링의 변경의 라이프 사이클이 다르므로 한 파일에 두면 유지보수하기 좋지 않다.
기능 특화 : JSP는 뷰 템플릿으로 화면을 렌더링하는데 최적화 되어있다.

Model-View-Controller

컨트롤러 : HTTP 요청을 받아 파라미터를 검증하고, 비즈니스 로직을 실행한다. 뷰에 전달할 결과 데이터를 조회해서 모델에 담는 역할을 한다.
모델 : 컨트롤러가 담은 데이터를 뷰에 전달한다. 뷰는 덕분에 비즈니스 로직이나 데이터 접근을 몰라도 되고, 화면을 렌더링하는 일에 집중할 수 있다.
뷰 : 모델에 담겨 있는 데이터를 사용해서 화면을 출력한다.

※참고※

일반적으로 실무에서 비즈니스 로직은 서비스라는 계층을 별도로 만들어서 처리하고, 컨트롤러는 비즈니스 로직이 있는 서비스를 호출하는 역할을 한다.

서블릿을 컨트롤러로, JSP를 뷰로 사용하기

기존에 구현했던 웹 애플리케이션을 MVC 패턴을 적용해서 리팩토링 해보자!

✅ 회원 등록 폼 - 컨트롤러 (Servlet)

@WebServlet(name =  "mvcMemberFormServlet",urlPatterns = "/servlet-mvc/members/new-form")
public class MvcMemberFormServlet extends HttpServlet {

    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        String viewPath = "/WEB-INF/views/new-form.jsp";
        RequestDispatcher dispatcher = request.getRequestDispatcher(viewPath);// controller에서 view로 이동할 때 사용
        dispatcher.forward(request, response);
    }
}

dispatcher.forward() : 다른 서블릿 또는 JSP로 이동할 수 있는 기능이다. 서버 내부에서 다시 호출이 발생한다. (리다이렉션 X)

※ 참고 ※

redirect vs forward

- redirect: 웹 브라우저에서 서버로 호출이 두번 발생. 처음 호출 + 리다이렉션 시 재호출, 클라이언트가 인지 가능

- forward: 웹 브라우저에서 서버로 호출은 한번만 발생. 서버 내부에서 여러 호출이 발생, 클라이언트가 인지 불가

✅ 회원 등록 폼 - 뷰 (JSP)

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<form action="save" method="post">
    username: <input type="text" name="username" />
    age:      <input type="text" name="age" />
    <button type="submit">전송</button>
</body>
</html>

JSP 파일이 /WEB-INF 경로에 있으면 외부에서 직접 JSP를 호출할 수 없다. 컨트롤러를 통해 호출하려면 이 경로에 파일을 둔다.

✅ 회원 저장 - 컨트롤러 (Servlet)

@WebServlet(name = "mvcMemberSaveServlet", urlPatterns = "/servlet-mvc/members/save")
public class MvcMemberSaveServlet extends HttpServlet {

    private MemberRepository memberRepository = MemberRepository.getInstance();

    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        String username = request.getParameter("username");
        int age = Integer.parseInt(request.getParameter("age"));

        // 인스턴스 생성해서 멤버 저장소에 저장
        Member member = new Member(username, age);
        memberRepository.save(member);

        // model에 데이터 보관
        request.setAttribute("member", member);

        String viewPath = "/WEB-INF/views/save-result.jsp";
        RequestDispatcher dispatcher = request.getRequestDispatcher(viewPath);
        dispatcher.forward(request, response);

    }
}

HttpServletRequest 객체를 Model로 사용한다.
request.setAttribute() 메서드를 사용해서 비즈니스 로직을 수행한 후 결과를 보관하고, 뷰로 전달한다.
이때 key=이름, value=member 형식으로 저장된다.

✅ 회원 저장 - 뷰 (JSP)

<ul>
    <!--(Member)(request.getAttribute("member")).getId()와 똑같은 역할-->
    <li>id=${member.id}</li>
    <li>username=${member.username}</li>
    <li>age=${member.age} </li>
</ul>

JSP가 제공하는 ${ } 문법을 사용해서 request의 attribute의 데이터를 편리하게 조회할 수 있다.

✅ 회원 목록 - 컨트롤러 (Servlet)

List<Member> members = memberRepository.findAll();

request.setAttribute("members", members);

List를 생성해서 모델에 보관한다.

✅ 회원 목록 - 뷰 (JSP)

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>

<c:forEach var="item" items="${members}"> <!--model의 attribure 이름으로 가져옴-->
    <tr>
        <td>${item.id}</td>
        <td>${item.username}</td>
        <td>${item.age}</td>
    </tr>
</c:forEach>

모델에 담아둔 리스트를 JSP가 제공하는 taglib 기능을 사용해 for문을 돌린 것 처럼 출력했다.
members 리스트에서 member를 순서대로 꺼내 item 변수에 담아 출력하는 과정을 반복한다.
이 기능을 사용하기 위해서는 첫줄처럼 선언해주어야 한다.
JSP와 같은 뷰 템플릿은 이렇게 화면을 렌더링하는데 특화된 다양한 기능을 제공한다.

서블릿과 JSP로 MVC 패턴 구현 시 한계

컨트롤러와 뷰 렌더링 역할을 명확하게 구분했지만, 컨트롤러에 중복되는 코드가 많다.

String viewPath = "/WEB-INF/views/new-form.jsp";
RequestDispatcher dispatcher = request.getRequestDispatcher(viewPath);
dispatcher.forward(request, response);

forward 중복 : dispatcher를 가져와 view로 이동하기 위한 코드가 항상 중복 호출되어야 한다.
viewPath 중복 : 경로 부분(prefix)과 확장자 부분(suffix)이 중복된다. 만약 폴더 전체를 바꾸거나 템플릿 엔진을 바꾸는 등 변경이 이루어지면 전체 코드를 수정해야 한다.
사용하지 않는 코드 : request 객체는 모델을 사용할 때에는 사용했지만 response 객체는 아예 사용하지 않았다. 또 이를 사용하는 코드는 테스트 케이스를 작성하기도 어렵다.

→ 공통 처리가 어렵다

이러한 문제들을 해결하기 위해서는 컨트롤러 호출전에 공통 기능을 처리해주면 된다. 모든 요청은 수문장 역할을 하는 객체(프론트 컨트롤러)를 통해서 들어와서 뒤에 있는 컨트롤러가 호출되도록 하자!

강의 링크

스프링 MVC 1편 - 백엔드 웹 개발 핵심 기술 - 인프런 | 강의

www.inflearn.com

[Spring] MVC 1편 (5) - 서블릿, JSP를 사용한 회원 관리 웹 애플리케이션

suaring — Tue, 29 Mar 2022 20:26:40 +0900

회원 관리 웹 애플리케이션 요구사항

회원 정보 : username(이름), age(나이)
기능 요구사항 : 회원 저장, 회원 조회

서블릿으로 구현하기

✅ 회원 등록 폼 - Servlet

@WebServlet(name = "memberFormServlet", urlPatterns = "/servlet/members/new-form")
public class MemberFormServlet extends HttpServlet {

    private MemberRepository memberRepository = MemberRepository.getInstance();

    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        // 응답으로 html 받기위해 설정
        response.setContentType("text/html");
        response.setCharacterEncoding("utf-8");

        PrintWriter w = response.getWriter();

        // form 작성시 form action 경로로 이동
        w.write("<!DOCTYPE html>\n" +
                "<html>\n" +
                "<head>\n" +
                " <meta charset=\"UTF-8\">\n" + " <title>Title</title>\n" +
                "</head>\n" +
                "<body>\n" +
                "<form action=\"/servlet/members/save\" method=\"post\">\n" +
                " username: <input type=\"text\" name=\"username\" />\n" +
                " age: <input type=\"text\" name=\"age\" />\n" +
                " <button type=\"submit\">전송</button>\n" +
                "</form>\n" +
                "</body>\n" +
                "</html>\n");

    }
}

고객에게 보여줄 Form 화면을 웹 브라우저에 전달한다.

✅ 회원 저장 - Servlet

@WebServlet(name = "memberSaveServlet", urlPatterns = "/servlet/members/save")
public class MemberSaveServlet extends HttpServlet {

    private MemberRepository memberRepository = MemberRepository.getInstance();

    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        System.out.println("MemberSaveServlet.service");
        // Form을 통해 넘어온 정보를 변수에 입력
        String username = request.getParameter("username");
        int age = Integer.parseInt(request.getParameter("age"));

        // 인스턴스 생성해서 멤버 저장소에 저장
        Member member = new Member(username, age);
        memberRepository.save(member);

	// 결과를 HTML로 반환
        response.setContentType("text/html");
        response.setCharacterEncoding("utf-8");

        PrintWriter w = response.getWriter();
        
        // 동적 HTML 생성
        w.write("<html>\n" +
                "<head>\n" +
                " <meta charset=\"UTF-8\">\n" +
                "</head>\n" +
                "<body>\n" +
                "성공\n" +
                "<ul>\n" +
                " <li>id="+member.getId()+"</li>\n" +
                " <li>username="+member.getUsername()+"</li>\n" +
                " <li>age="+member.getAge()+"</li>\n" +
                "</ul>\n" +
                "<a href=\"/index.html\">메인</a>\n" +
                "</body>\n" +
                "</html>");

    }
}

Form을 통해 입력된 정보를 request.getParameter() 메서드를 사용해 가져와 Member 객체를 생성한다.
이를 이용해서 비즈니스 로직을 수행하고 동적으로 HTML을 생성해서 전달한다.

✅ 회원 목록 - Servlet

@WebServlet(name = "memberListServlet", urlPatterns = "/servlet/members")
public class MemberListServlet extends HttpServlet {

    MemberRepository memberRepository = MemberRepository.getInstance();

    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        List<Member> memberList = memberRepository.findAll();

        response.setContentType("text/html");
        response.setCharacterEncoding("utf-8");

        PrintWriter w = response.getWriter();
        w.write("<html>");
        w.write("<head>");
        w.write(" <meta charset=\"UTF-8\">");
        w.write(" <title>Title</title>");
        w.write("</head>");
        w.write("<body>");
        w.write("<a href=\"/index.html\">메인</a>");
        w.write("<table>");
        w.write(" <thead>");
        w.write(" <th>id</th>");
        w.write(" <th>username</th>");
        w.write(" <th>age</th>");
        w.write(" </thead>");
        w.write(" <tbody>");

 	// memberRepository에 저장된 모든 멤버를 동적으로 출력
        for (Member member : memberList) {
            w.write(" <tr>");
            w.write(" <td>" + member.getId() + "</td>");
            w.write(" <td>" + member.getUsername() + "</td>");
            w.write(" <td>" + member.getAge() + "</td>");
            w.write(" </tr>");
        }
        w.write(" </tbody>");
        w.write("</table>"); w.write("</body>");
        w.write("</html>");
    }
}

동적으로 HTML을 생성할 때 for문을 사용할 수 있다.

✅ 템플릿 엔진

서블릿을 이용해서 동적으로 HTML을 생성할 수 있다.
하지만 자바 코드에서 HTML 코드를 한줄한줄 적는 것은 번거롭고 디버깅이 굉장히 힘들다.
이를 해결하기 위해 템플릿 엔진을 사용할 수 있다! e.g. JSP, Thymeleaf, Freemarker, Velocity
템플릿 엔진을 사용하면 HTML 코드에서 필요한 곳만 코드를 적용해서 동적으로 변경할 수 있다.

JSP로 구현하기

main/webapp 폴더 밑에 있는 파일은 기본적으로 호출된다.

✅ JSP 라이브러리 추가

//JSP 추가 시작
implementation 'org.apache.tomcat.embed:tomcat-embed-jasper'
implementation 'javax.servlet:jstl'
//JSP 추가 끝

JSP를 사용하기 위해 위 코드를 build.gradle에 추가해주어야 한다.

✅ 회원 등록 폼 - JSP

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<form action="/jsp/members/save.jsp" method="post">
    username: <input type="text" name="username" />
    age: <input type="text" name="age" />
    <button type="submit">전송</button>
</form>
</body>
</html>

첫줄은 JSP 문서임을 나타낸다.
HTML만 전달하는 회원 등록 폼에는 자바 코드가 들어가지 않고 HTML 코드와 거의 같다.

✅ 회원 저장 - JSP

<%@ page import="hello.servlet.domain.member.Member" %>
<%@ page import="hello.servlet.domain.member.MemberRepository" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
    MemberRepository memberRepository = MemberRepository.getInstance();
    // 넘어온 정보 변수에 입력
    String username = request.getParameter("username");
    int age = Integer.parseInt(request.getParameter("age"));
    // 인스턴스 생성해서 멤버 저장소에 저장
    Member member = new Member(username, age);
    memberRepository.save(member);
%>
<html>
<head>
    <title>Title</title>
</head>
<body>
성공
<ul>
    <li>id=<%=member.getId()%> </li>
    <li>username=<%=member.getUsername()%> </li>
    <li>age=<%=member.getAge()%> </li>
</ul>
<a href="/index.html">메인</a>
</body>
</html>

JSP 에서 자바 코드는 <%~~%> 안에 적어준다.
자바 코드를 출력하려면 <%=~~%> 안에 적어준다.
서블릿과 같이 request와 response를 사용할 수 있다.

✅ 회원 목록 - JSP

<%@ page import="java.util.List" %>
<%@ page import="hello.servlet.domain.member.MemberRepository" %>
<%@ page import="hello.servlet.domain.member.Member" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
    MemberRepository memberRepository = MemberRepository.getInstance();
    List<Member> members = memberRepository.findAll();
%>
<html>
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head><body>
<a href="/index.html">메인</a>
<table>
    <thead>
    <th>id</th>
    <th>username</th>
    <th>age</th>
    </thead>
    <tbody>
    <%
        for (Member member : members) {
            out.write(" <tr>");
            out.write(" <td>" + member.getId() + "</td>");
            out.write(" <td>" + member.getUsername() + "</td>");
            out.write(" <td>" + member.getAge() + "</td>");
            out.write(" </tr>");
        }
    %>
    </tbody>
</table>
</body>
</html>

비즈니스 코드를 실행하고, 결과 List를 사용해서 for문을 이용해 동적으로 HTML을 출력한다.

서블릿, JSP의 한계

서블릿을 사용하는 경우 뷰 화면을 위한 HTML 코드와 자바 코드가 섞여있어 지저분하고 복잡했다.
JSP를 사용하면 뷰를 생성하는 HTML 코드를 기본적으로 사용하면서 중간중간 동적으로 변경이 필요한 부분에만 자바 코드를 적용했다.
하지만 두가지 방법 모두 뷰와 비즈니스 로직을 한 파일 안에서 구현하기 때문에 각각 너무 많은 역할을 한다. (유지보수 어려움)
또한 대부분 뷰 부분과 비즈니스 로직의 변경은 동시에 발생하지 않는다. 변경의 라이프 사이클이 다른 부분을 하나의 코드에서 관리하는 것은 유지보수하기 좋지 않다.

→ MVC 패턴 등장!

강의 링크

스프링 MVC 1편 - 백엔드 웹 개발 핵심 기술 - 인프런 | 강의

Sue's devlog

[Kotlin] 코틀린 기초(1) : 변수, Null Safety, 타입

코틀린(Kotlin)이란?

변수

✅ 타입 추론과 명시적 타입

✅ 기본 타입

Null Safety : 코틀린의 핵심

✅ Safe Call과 Elvis 연산자

✅ null 아님 단언(!!)

✅ 플랫폼 타입

타입

1. 기본 타입

기본 타입 변환

2. 타입 캐스팅

3. 코틀린의 3가지 특이한 타입

4. String

연산자

✅ 동등성, 동일성

✅ 코틀린에 있는 특이한 연산자

✅ 연산자 오버로딩

[Programmers Level 2] 올바른 괄호

문제

첫번째 시도

결과

두번째 시도

결과

[Programmers Level 2] 전화번호 목록

문제

첫번째 시도

결과

두번째 시도

결과

AWS EC2 스프링 부트 프로젝트 gradlew test 오류 해결

상황

해결

[Spring] MVC 1편 (10) - 실용적인 스프링 MVC

@RequestMapping

컨트롤러 통합

실용적인 방식

강의 링크

[Spring] MVC 1편 (9) - 스프링 MVC 프레임워크 구조

스프링 MVC 구조

✅ 동작 순서

간단한 핸들러 매핑과 핸들러 어댑터 사용해보기

✅ 스프링 부트가 자동 등록하는 핸들러 매핑과 핸들러 어댑터

✅ 과정

간단한 뷰와 뷰 리졸버 사용해보기

✅ ViewResolver 설정 정보

✅ 스프링 부트가 자동 등록하는 뷰 리졸버

✅ 과정

강의 링크

[Spring] MVC 1편 (8) - MVC 프레임워크 만들기 v4,v5

v1, v2, v3

MVC 프레임워크 만들기

✅ v4 - 단순하고 실용적인 컨트롤러

✅ v5 - 유연한 컨트롤러

강의 링크

[Spring] MVC 1편 (7) - MVC 프레임워크 만들기 v1, v2, v3

프론트 컨트롤러

✅ 프론트 컨트롤러 도입 전

✅ 프론트 컨트롤러 도입 후

MVC 프레임워크 직접 만들어보기

✅ v1 - 프론트 컨트롤러 도입

✅ v2 - View 분리

✅ v3 - 모델 추가

강의 링크

[Spring] MVC 1편 (6) - MVC 패턴 적용

MVC 패턴 사용 이유?

Model-View-Controller

서블릿을 컨트롤러로, JSP를 뷰로 사용하기

✅ 회원 등록 폼 - 컨트롤러 (Servlet)

✅ 회원 등록 폼 - 뷰 (JSP)

✅ 회원 저장 - 컨트롤러 (Servlet)

✅ 회원 저장 - 뷰 (JSP)

✅ 회원 목록 - 컨트롤러 (Servlet)

✅ 회원 목록 - 뷰 (JSP)

서블릿과 JSP로 MVC 패턴 구현 시 한계

강의 링크

[Spring] MVC 1편 (5) - ​ 서블릿, JSP를 사용한 회원 관리 웹 애플리케이션

회원 관리 웹 애플리케이션 요구사항

[Spring] MVC 1편 (5) - 서블릿, JSP를 사용한 회원 관리 웹 애플리케이션