[SpringMVC] 타임리프 - 기본기능

스프링 MVC 2편 - 백엔드 웹 개발 활용 기술

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

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

www.inflearn.com

강의를 들으며 생각 정리

프로젝트 생성

스프링 부트 스타터(https://start.spring.io/) 에서 프로젝트를 생성한다.

간단하게 테스트(애플리케이션 실행 등) 해서 정상 작동하는지 확인한다.

+) 롬복의 경우 다음 링크를 참고해서 설치한다.

gksdudrb922.tistory.com/65

스프링 - 롬복(lombok) 라이브러리 설치

롬복 라이브러리는 도메인 클래스에서 getter/setter 메서드와 toString, equals, hashCode 등의 메서드를 애노테이션으로 사용할 수 있도록 해주는 라이브러리이다. 이외에도 몇 가지 기능이 존재하지만,

gksdudrb922.tistory.com

+) IntelliJ에서 Gradle 사용 시 주의점

gksdudrb922.tistory.com/66

IntelliJ에서 Gradle 사용시 자바 직접 실행

IntelliJ에서 Gradle 프로젝트 사용시 Gradle 대신에 자바 직접 실행 방법 최근 IntelliJ 버전은 Gradle로 실행을 하는 것이 기본 설정이다. 이렇게 하면 실행속도가 느리다. 다음과 같이 변경하면 자바로

gksdudrb922.tistory.com

+) Postman을 설치한다.

https://www.postman.com/downloads/

타임리프 소개

타임리프는 메뉴얼이 상당이 잘 되어있다. 처음부터 끝까지 쭉 읽는 것 보다는 필요에 따라서 해당 부분을 읽어보면 좋다.

공식 사이트: https://www.thymeleaf.org/
공식 메뉴얼 - 기본 기능: https://www.thymeleaf.org/doc/tutorials/3.0/usingthymeleaf.html
공식 메뉴얼 - 스프링 통합: https://www.thymeleaf.org/doc/tutorials/3.0/thymeleafspring.html

타임리프 특징

1. 서버 사이드 렌더링

타임리프는 백엔드 서버에서 HTML을 동적으로 렌더링하는 용도로 사용된다.

따라서 클라이언트를 거치지 않고 서버 단에서 바로 화면을 출력할 수 있다.

2. 네츄럴 템플릿

타임리프는 순수 HTML을 최대한 유지하는 특징이 있다.

JSP는 파일 자체를 그대로 웹 브라우저에서 열어보면 JSP 코드와 HTML이 뒤죽박죽 섰여서 정상적인 HTML 결과를 확인할 수 없다.

오직 서버를 통해서 JSP가 렌더링 되고 HTML 응답 결과를 받아야 정상 출력할 수 있다.

반면에 타임리프로 작성한 파일은 HTML을 유지하기 때문에 웹 브라우저에서 파일을 직접 열어도 내용을 확인할 수 있고, 서버를 통해 뷰 템플릿을 거치면 동적으로 변경된 결과를 확인할 수 있다.

이렇게 순수 HTML을 그대로 유지하면서 뷰 템플릿도 사용할 수 있는 타임리프의 특징을 네츄럴 템플릿이라 한다.

3. 스프링 통합 지원

타임리프는 스프링과 자연스럽게 통합되고, 스프링의 다양한 기능을 편리하게 사용할 수 있다.

이 부분은 나중에 다시 알아보겠다.

타임리프 사용 선언

타임리프를 사용하려면 다음 선언을 하면 된다.

<html xmlns:th="http://www.thymeleaf.org">

이제부터 타임리프의 기본 표현식들에 대해서 알아보자.

텍스트 - text, utext

text

타임리프의 가장 기본 기능인 텍스트를 출력하는 기능을 먼저 알아보자.

타임리프는 기본적으로 HTML 태그의 속성에 기능을 정의해서 동작한다.

HTMl 콘텐츠에 데이터를 출력할 때는 다음과 같이 th:text를 사용하면 된다.

<span th:text="${data}">

만약 HTML 태그의 속성이 아니라 HTML 콘텐츠 영역 안에서 직접 데이터를 출력하고 싶으면 다음과 같이 [[...]]를 사용하면 된다.

[[${data}]]

간단한 컨트롤러를 통해 text를 출력해보자.

</basic/BasicController>

@Controller
@RequestMapping("/basic")
public class BasicController {

    @GetMapping("/text-basic")
    public String textBasic(Model model) {
        model.addAttribute("data", "Hello Spring!");
        return "basic/text-basic";
    }
}

</baisc/text-basic.html>

+) 참고

앞으로 thymeleaf를 위한 html 파일은 모두 /resources/templates 아래에 만들어야 한다.

<!DOCTYPE html>
<html xml:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

<h1>컨텐츠에 데이터 출력하기</h1>
<ul>
    <li>th:text 사용 <span th:text="${data}"></span></li>
    <li>컨텐츠 안에서 직접 출력하기 = [[${data}]]</li>
</ul>
</body>
</html>

<결과>

이렇게 두 가지 방식으로 text를 출력할 수 있다.

만약 Hello Spring! 에서 Hello Spring! 처럼 특정 부분을 강조하고 싶다면 어떻게 할까?

모델에 데이터를 담을 때 태그를 넣어주면 되지 않을까?

model.addAttribute("data", "Hello <b>Spring!</b>");

하지만 실제로 출력한 결과는 다음과 같다.

의도한 것과 다르게 태그가 그대로 출력된다.

실제로 페이지 소스를 보면 다음과 같다.

<!DOCTYPE html>
<html xml:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

<h1>컨텐츠에 데이터 출력하기</h1>
<ul>
    <li>th:text 사용 <span>Hello &lt;b&gt;Spring!&lt;/b&gt;</span></li>
    <li>컨텐츠 안에서 직접 출력하기 = Hello &lt;b&gt;Spring!&lt;/b&gt;</li>
</ul>
</body>
</html>

부등호 <, >가 < >로 찍혀있는 것을 볼 수 있다. 이게 대체 뭘까?

이를 이해하기 위해 Escape를 이해할 필요가 있다.

Escape

HTML 문서는 <, >과 같은 특수 문자를 기반으로 정의된다. 예를 들어, 태그는 <b> 처럼 부등호를 사용해서 나타낸다.

만약 화면에 <, >를 출력하고 싶다면? <, >를 그대로 html 파일에 입력하면 태그로 인식하기 때문에 다른 표현 방식을 찾아야 한다.

따라서,

'<' -> '<"

'>' -> '>"

처럼 다른 표현 방식을 사용하게 되는데, '<"와 같은 표현을 HTML 엔티티라고 하고

특수 문자를 HTML 엔티티로 변경하는 것을 이스케이프(escape)라고 한다.

그리고 타임리프가 제공하는 th:text, [[...]]는 기본적으로 이스케이프를 제공한다.

Unescape

이스케이프 기능을 사용하지 않으려면 어떻게 해야할까?

타임리프는 다음 두 기능을 제공한다.

th:text -> th:utext

[[...]] -> [(...)]

</basic/text-unescaped.html>

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
  <meta charset="UTF-8">
  <title>Title</title>
</head>
<body>
<h1>text vs utext</h1>
<ul>
  <li>th:text = <span th:text="${data}"></span></li>
  <li>th:utext = <span th:utext="${data}"></span></li>
</ul>
<h1><span th:inline="none">[[...]] vs [(...)]</span></h1>
<ul>
  <li><span th:inline="none">[[...]] = </span>[[${data}]]</li>
  <li><span th:inline="none">[(...)] = </span>[(${data})]</li>
</ul>
</body>
</html>

+) th:inline="none"

타임리프는 [[...]]를 해석하기 때문에, 화면에 [[...]] 글자를 보여줄 수 없다. 이 태그 안에서는 타임리프가 해석하지 말라는 옵션이다.

<결과>

변수 - SpringEL

변수 표현식

타임리프에서 변수를 사용할 때는 변수 표현식을 사용한다.

변수 표현식 : ${...}

그리고 이 변수 표현식에는 스프링이 제공하는 표현식인 SpringEL을 사용할 수 있다.

</baisc/BasicController>

@GetMapping("/variable")
public String variable(Model model) {
    User userA = new User("userA", 10);
    User userB = new User("userB", 20);

    List<User> list = new ArrayList<>();
    list.add(userA);
    list.add(userB);

    Map<String, User> map = new HashMap<>();
    map.put("userA", userA);
    map.put("userB", userB);

    model.addAttribute("user", userA);
    model.addAttribute("users", list);
    model.addAttribute("userMap", map);

    return "basic/variable";
}

@Data
static class User {

    private String username;
    private int age;

    public User(String username, int age) {
        this.username = username;
        this.age = age;
    }
}

User 클래스에 대한 클래스, 리스트, 맵을 모델에 저장한다.

</basic/variable.html>

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
  <meta charset="UTF-8">
  <title>Title</title>
</head>
<body>
<h1>SpringEL 표현식</h1>
<ul>Object
  <li>${user.username} = <span th:text="${user.username}"></span></li>
  <li>${user['username']} = <span th:text="${user['username']}"></span></li>
  <li>${user.getUsername()} = <span th:text="${user.getUsername()}"></span></
  li>
</ul>
<ul>List
  <li>${users[0].username} = <span th:text="${users[0].username}"></span></li>
  <li>${users[0]['username']} = <span th:text="${users[0]['username']}"></span></li>
  <li>${users[0].getUsername()} = <span th:text="${users[0].getUsername()}"></span></li>
</ul>
<ul>Map
  <li>${userMap['userA'].username} = <span th:text="${userMap['userA'].username}"></span></li>
  <li>${userMap['userA']['username']} = <span th:text="${userMap['userA']['username']}"></span></li>
  <li>${userMap['userA'].getUsername()} = <span th:text="${userMap['userA'].getUsername()}"></span></li>
</ul>
</body>
</html>

<결과>

설명보다는 코드를 보면 SpringEL의 다양한 표현식에 대해 직관적으로 이해할 수 있다.

보통 가장 간편한 첫 번째 방식(user.username)을 많이 사용한다.

지역 변수

th:with를 사용하면 지역 변수를선언할 수 있다.

단, 지역 변수는 선언한 태그 안에서만 사용할 수 있다.

</basic/variable.html - 추가>

<h1>지역 변수 - (th:with)</h1>
<div th:with="first=${users[0]}">
  <p>처음 사람의 이름은 <span th:text="${first.username}"></span></p>
</div>

<결과>

기본 객체들

타임리프는 기본 객체들을 제공한다. 코드로 바로 알아보자.

</basic/BasicController>

@GetMapping("/basic-objects")
public String basicObjects(HttpSession session) {
    session.setAttribute("sessionData", "Hello Session");
    return "basic/basic-objects"; 
}

@Component("helloBean") 
static class HelloBean {
    public String hello(String data) { 
        return "Hello " + data;
    } 
}

</basic/basic-obejcts.html>

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
 <meta charset="UTF-8">
 <title>Title</title>
</head>
<body>
<h1>식 기본 객체 (Expression Basic Objects)</h1>
<ul>
 <li>request = <span th:text="${#request}"></span></li>
 <li>response = <span th:text="${#response}"></span></li>
 <li>session = <span th:text="${#session}"></span></li>
 <li>servletContext = <span th:text="${#servletContext}"></span></li>
 <li>locale = <span th:text="${#locale}"></span></li>
</ul>
<h1>편의 객체</h1>
<ul>
 <li>Request Parameter = <span th:text="${param.paramData}"></span></li>
 <li>session = <span th:text="${session.sessionData}"></span></li>
 <li>spring bean = <span th:text="${@helloBean.hello('Spring!')}"></span></li>
</ul>
</body>
</html>

<결과>

HttpServeletRequest와 같은 기본적인 서블릿, 세션 관련 객체를 제공한다.
또한 요청 파라미터에 대해 request.getParameter('data')로 불편하게 접근하지 않고, paramter와 같은 편의 객체도 제공한다.

HTTP 요청 파라미터 접근: paramData HTTP 세션 접근: sessionData
스프링 빈 접근: @helloBean.hello('Spring!')

+) 스프링 부트 3.0부터는 ${#request}와 같은 기본 객체를 지원하지 않는다.
따라서, model.addAttribute("request", request)와 같이 모델에 직접 객체를 추가해서 사용해야 한다.

유틸리티 객체와 날짜

타임리프는 문자, 숫자 날짜, URI 등을 편리하게 다루는 다양한 유틸리티 객체들을 제공한다.

+) 참고

타임리프 유틸리티 객체: https://www.thymeleaf.org/doc/tutorials/3.0/usingthymeleaf.html#expressionutility-objects

유틸리티 객체 예시: https://www.thymeleaf.org/doc/tutorials/3.0/usingthymeleaf.html#appendix-b-expressionutility-objects

→ 이런 유틸리티 객체들이 있다 정도로 알아두고, 필요할 때 찾아보자.

+) 참고 참고로 자바 8에서 날짜 객체인 LocalDateTime 등을 사용하려면 추가 라이브러리(thymeleaf-extras-java8time)가 필요 하다.

그러나, 스프링부트 타임리프를 사용하면 해당 라이브러리가 자동으로 추가된다.

</basic/BasicController>

@GetMapping("/date")
public String date(Model model) {
    model.addAttribute("localDateTime", LocalDateTime.now());
    return "basic/date";
}

</basic/date.html>

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
 <meta charset="UTF-8">
 <title>Title</title>
</head>
<body>
<h1>LocalDateTime</h1>
<ul>
 <li>default = <span th:text="${localDateTime}"></span></li>
 <li>yyyy-MM-dd HH:mm:ss = <span th:text="${#temporals.format(localDateTime,'yyyy-MM-dd HH:mm:ss')}"></span></li>
</ul>
<h1>LocalDateTime - Utils</h1>
<ul>
 <li>${#temporals.day(localDateTime)} = <span th:text="${#temporals.day(localDateTime)}"></span></li>
 <li>${#temporals.month(localDateTime)} = <span th:text="${#temporals.month(localDateTime)}"></span></li>
 <li>${#temporals.monthName(localDateTime)} = <span th:text="${#temporals.monthName(localDateTime)}"></span></li>
 <li>${#temporals.monthNameShort(localDateTime)} = <span th:text="${#temporals.monthNameShort(localDateTime)}"></span></li>
 <li>${#temporals.year(localDateTime)} = <span th:text="${#temporals.year(localDateTime)}"></span></li>
 <li>${#temporals.dayOfWeek(localDateTime)} = <span th:text="${#temporals.dayOfWeek(localDateTime)}"></span></li>
 <li>${#temporals.dayOfWeekName(localDateTime)} = <span th:text="${#temporals.dayOfWeekName(localDateTime)}"></span></li>
 <li>${#temporals.dayOfWeekNameShort(localDateTime)} = <span th:text="${#temporals.dayOfWeekNameShort(localDateTime)}"></span></li>
 <li>${#temporals.hour(localDateTime)} = <span th:text="${#temporals.hour(localDateTime)}"></span></li>
 <li>${#temporals.minute(localDateTime)} = <span th:text="${#temporals.minute(localDateTime)}"></span></li>
 <li>${#temporals.second(localDateTime)} = <span th:text="${#temporals.second(localDateTime)}"></span></li>
 <li>${#temporals.nanosecond(localDateTime)} = <span th:text="${#temporals.nanosecond(localDateTime)}"></span></li>
</ul>
</body>
</html>

<결과>

URL 링크

타임리프에서 URL을 생성할 때는 @{...} 문법을 사용하면 된다.

</basic/BasicController>

@GetMapping("/link")
public String link(Model model) {
    model.addAttribute("param1", "data1");
    model.addAttribute("param2", "data2"); 
    return "basic/link";
}

</basic/link.html>

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
 <meta charset="UTF-8">
 <title>Title</title>
</head>
<body>
<h1>URL 링크</h1>
<ul>
    <!-- /hello -->
    <li><a th:href="@{/hello}">basic url</a></li>
    <!-- /hello?param1=data1&param2=data2: () 안에 있는 부분은 쿼리 파라미터로 처리된다 -->
    <li><a th:href="@{/hello(param1=${param1}, param2=${param2})}">hello queryparam</a></li>
    <!-- /hello/data1/data2: URL 경로 상테 변수가 있으면 () 부분은 경로 변수로 처리된다 -->
    <li><a th:href="@{/hello/{param1}/{param2}(param1=${param1}, param2=${param2})}">path variable</a></li>
    <!-- /hello/data1?param2=data2: 경로 변수와 쿼리 파라미터를 함께 사용할 수 있다 -->
    <li><a th:href="@{/hello/{param1}(param1=${param1}, param2=${param2})}">pathvariable + query parameter</a></li>
</ul>
</body>
</html>

<결과>

리터럴

리터럴은 소스 코드상에 고정된 값을 말하는 용어이다.

ex) "Hello": 문자 리터럴, 10: 숫자 리터럴

중요!: 타임리프에서 문자 리터럴은 항상 작은 따옴표('')로 감싸야 한다.

<span th:text="'hello'">

그런데 문자를 항상 '' 로 감싸는 것은 너무 귀찮은 일이다.

그래서 타임리프는 문자열이 공백 없이 쭉 이어진다면 하나의 리터럴로 인식해서 ''를 생략할 수 있다.

<span th:text="hello"> <!-- OK -->
<span th:text="hello world!"></span> <!-- 공백이 있기 때문에 오류! -->

</basic/BasicController>

@GetMapping("/literal")
public String literal(Model model) {
    model.addAttribute("data", "Spring!");
    return "basic/literal";
}

</basic/literal.html>

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
 <meta charset="UTF-8">
 <title>Title</title>
</head>
<body>
<h1>리터럴</h1>
<ul>
 <!--주의! 다음 주석을 풀면 예외가 발생함-->
 <!-- <li>"hello world!" = <span th:text="hello world!"></span></li>-->
 <li>'hello' + ' world!' = <span th:text="'hello' + ' world!'"></span></li>
 <li>'hello world!' = <span th:text="'hello world!'"></span></li>
 <li>'hello ' + ${data} = <span th:text="'hello ' + ${data}"></span></li>
 <li>리터럴 대체 |hello ${data}| = <span th:text="|hello ${data}|"></span></li>
</ul>
</body>
</html>

<결과>

연산

타임리프 연산은 자바와 크게 다르지 않다.

</basic/BasicController>

@GetMapping("/operation")
public String operation(Model model) {
    model.addAttribute("nullDate", null);
    model.addAttribute("data", "Spring!");
    return "basic/operation";
}

</basic/operation.html>

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
 <meta charset="UTF-8">
 <title>Title</title>
</head>
<body>
<ul>
 <li>산술 연산
 <ul>
 <li>10 + 2 = <span th:text="10 + 2"></span></li>
 <li>10 % 2 == 0 = <span th:text="10 % 2 == 0"></span></li>
 </ul>
 </li>
 <li>비교 연산
 <ul>
 <li>1 > 10 = <span th:text="1 > 10"></span></li>
 <li>1 gt 10 = <span th:text="1 gt 10"></span></li>
 <li>1 >= 10 = <span th:text="1 >= 10"></span></li>
 <li>1 ge 10 = <span th:text="1 ge 10"></span></li>
 <li>1 == 10 = <span th:text="1 == 10"></span></li>
 <li>1 != 10 = <span th:text="1 != 10"></span></li>
 </ul>
 </li>
 <li>조건식
 <ul>
 <li>(10 % 2 == 0)? '짝수':'홀수' = <span th:text="(10 % 2 == 0)?'짝수':'홀수'"></span></li>
 </ul>
 </li>
 <li>Elvis 연산자
 <ul>
 <li>${data}?: '데이터가 없습니다.' = <span th:text="${data}?: '데이터가없습니다.'"></span></li>
 <li>${nullData}?: '데이터가 없습니다.' = <span th:text="${nullData}?:'데이터가없습니다.'"></span></li>
 </ul>
 </li>
 <li>No-Operation
 <ul>
 <li>${data}?: _ = <span th:text="${data}?: _">데이터가 없습니다.</span></li>
 <li>${nullData}?: _ = <span th:text="${nullData}?: _">데이터가없습니다.</span></li>
 </ul>
 </li>
</ul>
</body>
</html>

<결과>

속성 값 설정

타임리프는 주로 HTML 태그에 th:* 속성을 지정하는 방식으로 동작한다. th:* 속성을 적용하면 기존 속성을 대체한다.
-> 기존 속성이 없으면 새로 만든다.

</basic/BasicController>

@GetMapping("/attribute")
public String attribute() {
    return "basic/attribute";
}

</basic/attribute.html>

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

<h1>속성 설정</h1>
<input type="text" name="mock" th:name="userA" />

<h1>속성 추가</h1>
- th:attrappend = <input type="text" class="text" th:attrappend="class=' large'" /><br/>
- th:attrprepend = <input type="text" class="text" th:attrprepend="class='large '" /><br/>
- th:classappend = <input type="text" class="text" th:classappend="large" /><br/>

<h1>checked 처리</h1>
- checked o <input type="checkbox" name="active" th:checked="true" /><br/>
- checked x <input type="checkbox" name="active" th:checked="false" /><br/>
- checked=false <input type="checkbox" name="active" checked="false" /><br/>

</body>
</html>

속성 추가

th:attrappend: 속성 값의 뒤에 값을 추가한다.

th:attrprepend: 속성 값의 앞에 값을 추가한다.

th:classappend: class 속성에 자연스럽게 추가한다.

checked 처리

HTML에서 "<input type="checkbox" name="active" checked="false">", 이 경우에도 checked 속성이 있기 때문에 checked 처리가 되어버린다.

타임리프의 checked 속성은 값이 false인 경우 checked 속성 자체를 제거한다.

<결과 - 페이지 소스 보기>

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

<h1>속성 설정</h1>
<input type="text" name="userA" />

<h1>속성 추가</h1>
- th:attrappend = <input type="text" class="text large" /><br/>
- th:attrprepend = <input type="text" class="large text" /><br/>
- th:classappend = <input type="text" class="text large" /><br/>

<h1>checked 처리</h1>
- checked o <input type="checkbox" name="active" checked="checked" /><br/>
- checked x <input type="checkbox" name="active" /><br/>
- checked=false <input type="checkbox" name="active" checked="false" /><br/>

</body>
</html>

th:* 속성이 기존 속성을 대체한 것을 볼 수 있다.

반복

타임리프에서 반복은 th:each를 사용한다.

</basic/BasicController>

@GetMapping("/each")
public String each(Model model) {
    addUsers(model);
    return "basic/each";
}

private void addUsers(Model model) {
    List<User> list = new ArrayList<>();
    list.add(new User("userA", 10));
    list.add(new User("userB", 20));
    list.add(new User("userC", 30));
    model.addAttribute("users", list);
}

</basic/each.html>

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
  <meta charset="UTF-8">
  <title>Title</title>
</head>
<body>
<h1>기본 테이블</h1>
<table border="1">
  <tr>
    <th>username</th>
    <th>age</th>
  </tr>
  <tr th:each="user : ${users}">
    <td th:text="${user.username}">username</td>
    <td th:text="${user.age}">0</td>
  </tr>
</table>

<h1>반복 상태 유지</h1>

<table border="1">
  <tr>
    <th>count</th>
    <th>username</th>
    <th>age</th>
    <th>etc</th>
  </tr>
  <tr th:each="user, userStat : ${users}">
    <td th:text="${userStat.count}">username</td>
    <td th:text="${user.username}">username</td>
    <td th:text="${user.age}">0</td>
    <td>
      index = <span th:text="${userStat.index}"></span>
      count = <span th:text="${userStat.count}"></span>
      size = <span th:text="${userStat.size}"></span>
      even? = <span th:text="${userStat.even}"></span>
      odd? = <span th:text="${userStat.odd}"></span>
      first? = <span th:text="${userStat.first}"></span>
      last? = <span th:text="${userStat.last}"></span>
      current = <span th:text="${userStat.current}"></span>
    </td>
  </tr>
</table>


</body>
</html>

th:each는 List뿐만 아니라, Iterable을 구현한 모든 객체에 사용할 수 있다.
-> Map의 경우 Map.Entry가 담긴다.

반복 상태 유지

반복의 두번째 파라미터를 설정해서 반복의 상태를 확인할 수 있다.

+) 생략도 가능한데, 생락하면 지정한 변수명(user) + Stat이 된다.

<결과>

조건부 평가

타임리프의 조건식은 if, unless(if의 반대)를 사용한다.

</basic/BasicController>

@GetMapping("/condition")
public String condition(Model model) {
    addUsers(model);
    return "basic/condition";
}

</basic/condition.html>

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>if, unless</h1>
<table border="1">
    <tr>
        <th>count</th>
        <th>username</th>
        <th>age</th>
    </tr>
    <tr th:each="user, userStat : ${users}">
        <td th:text="${userStat.count}">1</td>
        <td th:text="${user.username}">username</td>
        <td>
            <span th:text="${user.age}">0</span>
            <span th:text="'미성년자'" th:if="${user.age lt 20}"></span>
            <span th:text="'미성년자'" th:unless="${user.age ge 20}"></span>
        </td>
    </tr>
</table>

<h1>switch</h1>
<table border="1">
    <tr>
        <th>count</th>
        <th>username</th>
        <th>age</th>
    </tr>
    <tr th:each="user, userStat : ${users}">
        <td th:text="${userStat.count}">1</td>
        <td th:text="${user.username}">username</td>
        <td th:switch="${user.age}">
            <span th:case="10">10살</span>
            <span th:case="20">20살</span>
            <span th:case="*">기타</span>
        </td>
    </tr>
</table>

</body>
</html>

if, unless 조건을 충족하지 않으면 해당 <span> 태그 자체가 렌더링되지 않는다.

switch case문의 경우 '*'은 조건이 없을 때 사용하는 default를 나타낸다.

<결과>

주석

</basic/BasicController>

@GetMapping("/comments")
public String comments(Model model) {
    model.addAttribute("data", "Spring!");
    return "basic/comments";
}

</basic/comments.html>

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

<h1>예시</h1>
<span th:text="${data}">html data</span>

<h1>1. 표준 HTML 주석</h1>
<!--
<span th:text="${data}">html data</span>
-->

<h1>2. 타임리프 파서 주석</h1>
<!--/* [[${data}]] */-->

<!--/*-->
<span th:text="${data}">html data</span>
<!--*/-->

<h1>3. 타임리프 프로토타입 주석</h1>
<!--/*/
<span th:text="${data}">html data</span>
/*/-->

</body>
</html>

1. 표준 HTML 주석 (

자바스크립트의 표준 HTML 주석은 타임리프가 렌더링하지 않고, 그대로 남겨둔다.

2. 타임리프 파서 주석 (!--/*--> ... !--/*-->)

타임리프의 진짜 주석이다. 렌더링에서 주석 부분을 제거한다.

3. 타임리프 프로토타입 주석()

HTML 주석에 약간의 구문을 더했다.

HTML 파일을 그대로 열면 주석처리되지만, 타임리프를 렌더링한 경우 주석 안의 내용이 보이는 기능이다.

<결과 - 페이지 소스 보기>

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

<h1>예시</h1>
<span>Spring!</span>

<h1>1. 표준 HTML 주석</h1>
<!--
<span th:text="${data}">html data</span>
-->

<h1>2. 타임리프 파서 주석</h1>




<h1>3. 타임리프 프로토타입 주석</h1>

<span>Spring!</span>


</body>
</html>

블록

<th:block>은 HTML 태그가 아닌 타임리프의 유일한 자체 태그다.

</basic/BasicController>

@GetMapping("/block")
public String block(Model model) {
    addUsers(model); 
    return "basic/block";
}

</basic/block.html>

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

<th:block th:each="user : ${users}">
    <div>
        사용자 이름1 <span th:text="${user.username}"></span>
        사용자 나이1 <span th:text="${user.age}"></span>
    </div>
    <div>
        요약 <span th:text="${user.username} + ' / ' + ${user.age}"></span>
    </div>
</th:block>

</body>
</html>

만약 <div></div> 두개를 한번에 반복하고 싶다면 <th:block>을 사용할 수 있다.

Q: 그냥 큰 범위의 <div th:each></div>에 작은 범위의 <div></div>를 넣으면 되지 않나?

A: 아래 결과를 보자.

<결과>

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>


    <div>
        사용자 이름1 <span>UserA</span>
        사용자 나이1 <span>10</span>
    </div>
    <div>
        요약 <span>UserA / 10</span>
    </div>

    <div>
        사용자 이름1 <span>UserB</span>
        사용자 나이1 <span>20</span>
    </div>
    <div>
        요약 <span>UserB / 20</span>
    </div>

    <div>
        사용자 이름1 <span>UserC</span>
        사용자 나이1 <span>30</span>
    </div>
    <div>
        요약 <span>UserC / 30</span>
    </div>


</body>
</html>

실제 렌더링 시 <th:block>은 사라진다.

<div th:each>를 사용했다면 div 태그가 남아있을 것이다.

-> 이처럼 <th:block>은 자주 사용하지는 않지만 원하는 HTML 형식이 있을 때 사용할 수 있다.

자바스크립트 인라인

타임리프는 자바스크립트에서 타임리프를 편리하게 사용할 수 있는 자바스크립트 인라인 기능을 제공한다.

자바스크립트 인라인 기능은 다음과 같이 적용하면 된다.

<script th:inline="javascript">

</basic/BasicController>

@GetMapping("/javascript")
public String javascript(Model model) {

    model.addAttribute("user", new User("UserA", 10));
    addUsers(model);

    return "basic/javascript";
}

</basic/javascript.html>

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

<!-- 자바스크립트 인라인 사용 전 -->
<script>

    var username = [[${user.username}]];
    var age = [[${user.age}]];

    //자바스크립트 내추럴 템플릿
    var username2 = /*[[${user.username}]]*/ "test username";

    //객체
    var user = [[${user}]];
</script>

<!-- 자바스크립트 인라인 사용 후 -->
<script th:inline="javascript">
    var username = [[${user.username}]];
    var age = [[${user.age}]];

    //자바스크립트 내추럴 템플릿
    var username2 = /*[[${user.username}]]*/ "test username";

    //객체
    var user = [[${user}]];
</script>

<!-- 자바스크립트 인라인 each -->
<script th:inline="javascript">

    [# th:each="user, stat : ${users}"]
    var user[[${stat.count}]] = [[${user}]];
    [/]

</script>

</body>
</html>

<결과 - 페이지 소스 보기>

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

<!-- 자바스크립트 인라인 사용 전 -->
<script>

    var username = UserA;
    var age = 10;

    //자바스크립트 내추럴 템플릿
    var username2 = /*UserA*/ "test username";

    //객체
    var user = BasicController.User(username=UserA, age=10);
</script>

<!-- 자바스크립트 인라인 사용 후 -->
<script>
    var username = "UserA";
    var age = 10;

    //자바스크립트 내추럴 템플릿
    var username2 = "UserA";

    //객체
    var user = {"username":"UserA","age":10};
</script>

<!-- 자바스크립트 인라인 each -->
<script>

    
    var user1 = {"username":"UserA","age":10};
    var user2 = {"username":"UserB","age":20};
    var user3 = {"username":"UserC","age":30};
    

</script>

</body>
</html>

자바스크립트 인라인을 사용하지 않은 경우와, 사용한 경우를 비교하면 이렇다.

1. 텍스트 렌더링

var username = [[${user.username}]];

// 인라인 사용 전
var username = userA;

// 인라인 사용 후
var username = "userA";

인라인 사용 전 결과는 userA라는 변수 이름이 그대로 대입되기 때문에 오류를 발생한다.

타임리프 입장에서는 정확하게 렌더링한 것이지만 개발자 입자에서는 "userA"를 기대했을 것이다.

인라인을 사용하면 문자 타입의 경우 자동으로 ""를 포함해준다.

2. 자바스크립트 내추럴 템플릿

var username2 = /*[[${user.username}]]*/ "test username";

// 인라인 사용 전
var username2 = /*userA*/ "test username";

// 인라인 사용 후
var username2 = "userA";

타임리프는 자바스크립트에서도 내추럴 템플릿을 제공하는데, 위와 같은 문법을 사용하면 된다.

그러나 인라인 사용 전 결과는 타임리프가 정말 순수하게 그대로 해석을 한 것이고,

인라인 사용 후 결과는 주석 부분이 제거되고 기대한 "userA"가 정확하게 적용된다.

3. 객체

var user = [[${user}]];

// 인라인 사용 전
var user = BasicController.User(username=userA, age=10);

// 인라인 사용 후
var user = {"username":"userA","age":10};

인라인 사용 전은 객체의 toString()이 호출된다.

인라인 사용 후는 객체를 JSON String으로 변환해 준다.

4. 자바스크립트 인라인 each

자바스크립트 인라인은 each를 지원한다.

<!-- 자바스크립트 인라인 each -->
<script th:inline="javascript">

    [# th:each="user, stat : ${users}"]
    var user[[${stat.count}]] = [[${user}]];
    [/]

</script>

템플릿 조각

웹 페이지를 개발할 때는 공통 영역이 많이 있다. (상단, 하단 영역 등)

이런 부분들의 중복을 방지하기 위해 타임리프는 템플릿 조각과 레이아웃 기능을 제공한다.

</basic/TemplateController>

@Controller
@RequestMapping("/template")
public class TemplateController {

    @GetMapping("/fragment")
    public String template() {
        return "template/fragment/fragmentMain";
    }
}

</template/fragment/footer.html>

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">

<body>

<footer th:fragment="copy">
    푸터 자리 입니다.
</footer>

<footer th:fragment="copyParam (param1, param2)">
    <p>파라미터 자리 입니다.</p>
    <p th:text="${param1}"></p>
    <p th:text="${param2}"></p>
</footer>

</body>

</html>

</template/fragment/fragmentMain.html>

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>부분 포함</h1>
<h2>부분 포함 insert</h2>
<div th:insert="~{template/fragment/footer :: copy}"></div>

<h2>부분 포함 replace</h2>
<div th:replace="~{template/fragment/footer :: copy}"></div>

<h2>부분 포함 단순 표현식</h2>
<div th:replace="template/fragment/footer :: copy"></div>

<h1>파라미터 사용</h1>
<div th:replace="~{template/fragment/footer :: copyParam ('데이터1', '데이터2')}"></div>
</body>
</html>

"/template/fragment/footer :: copy"는 /template/fragment/footer.html에 있는 th:fragment="copy"라는 부분을 템플릿 조각으로 가져와서 사용한다는 의미이다.

사용하는 부분은 th:insert와 th:replace로 나뉘는데, <div>태그 안에 내용을 추가할 건지, 대체할 건지 차이이다.

결과를 보면 이해가 될 것이다.

<결과 - 페이지 소스 보기>

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>부분 포함</h1>
<h2>부분 포함 insert</h2>
<div><footer>
    푸터 자리 입니다.
</footer></div>

<h2>부분 포함 replace</h2>
<footer>
    푸터 자리 입니다.
</footer>

<h2>부분 포함 단순 표현식</h2>
<footer>
    푸터 자리 입니다.
</footer>

<h1>파라미터 사용</h1>
<footer>
    <p>파라미터 자리 입니다.</p>
    <p>데이터1</p>
    <p>데이터2</p>
</footer>
</body>
</html>

템플릿 레이아웃

템플릿 조각은 외부 파일의 일부 코드 조각을 main 파일에 가져와서 사용했다면,

템플릿 레이아웃은 main 파일의 코드 조각을 레이아웃에 넘겨서 사용하는 방법이다.

다음은 <head>에 공통으로 사용하는 css, javascript 파일이 있는데, 이러한 공통 정보를 한 곳에 모아두고, 각 페이지마다 필요한 정보를 더 추가해서 사용하는 예시이다.

</basic/TemplateController>

@GetMapping("layout")
public String layout() {
    return "template/layout/layoutMain";
}

</template/layout/base.html>

<html xmlns:th="http://www.thymeleaf.org">
<head th:fragment="common_header(title,links)">

    <title th:replace="${title}">레이아웃 타이틀</title>

    <!-- 공통 -->
    <link rel="stylesheet" type="text/css" media="all" th:href="@{/css/awesomeapp.css}">
    <link rel="shortcut icon" th:href="@{/images/favicon.ico}">
    <script type="text/javascript" th:src="@{/sh/scripts/codebase.js}"></script>

    <!-- 추가 -->
    <th:block th:replace="${links}" />

</head>

</template/layout/layoutMain.html>

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head th:replace="{template/layout/base :: common_header({::title},~{::link})}">
    <title>메인 타이틀</title>
    <link rel="stylesheet" th:href="@{/css/bootstrap.min.css}">
    <link rel="stylesheet" th:href="@{/themes/smoothness/jquery-ui.css}">
</head>
<body>
메인 컨텐츠
</body>
</html>

"common_header(~{::title},~{::link})"를 통해,

::title(현재 페이지의 <title> 태그들), ::link(현재 페이지의 link 태그들)을 base.html에 전달한다.

<결과 - 페이지 소스 보기>

<!DOCTYPE html>
<html>
<head>

    <title>메인 타이틀</title>

    <!-- 공통 -->
    <link rel="stylesheet" type="text/css" media="all" href="/css/awesomeapp.css">
    <link rel="shortcut icon" href="/images/favicon.ico">
    <script type="text/javascript" src="/sh/scripts/codebase.js"></script>

    <!-- 추가 -->
    <link rel="stylesheet" href="/css/bootstrap.min.css"><link rel="stylesheet" href="/themes/smoothness/jquery-ui.css">

</head>
<body>
메인 컨텐츠
</body>
</html>

<title> 태그가 전달한 부분으로 교체되었다.

공통 부분은 그대로 유지되고, 추가 부분에 전달한 <link> 태그들이 포함되었다.

템플릿 레이아웃 확장

앞서 이야기한 개념을 <head> 정도에만 적용하는게 아니라 <html> 전체에 적용할 수도 있다.

</basic/TemplateController>

@GetMapping("/layoutExtend")
public String layoutExtend() {
    return "template/layoutExtend/layoutExtendMain";
}

</template/layout/layoutFile.html>

<!DOCTYPE html>
<html th:fragment="layout (title, content)" xmlns:th="http://www.thymeleaf.org">
<head>
    <title th:replace="${title}">레이아웃 타이틀</title>
</head>
<body>
<h1>레이아웃 H1</h1>
<div th:replace="${content}">
    <p>레이아웃 컨텐츠</p>
</div>
<footer>
    레이아웃 푸터
</footer>
</body>
</html>

전체에 th:fragment 속성이 정의되어 있다.

어떤 페이지든 이 layoutFile.html을 기본으로 하고 여기에 필요한 내용을 전달해서 부분부분 변경하는 것으로 이해하면 된다.

</template/layout/layoutExtendMain.html>

<!DOCTYPE html>
<html th:replace="~{template/layoutExtend/layoutFile :: layout(~{::title}, ~{::section})}"
      xmlns:th="http://www.thymeleaf.org">
<head>
    <title>메인 페이지 타이틀</title>
</head>
<body>
<section>
    <p>메인 페이지 컨텐츠</p>
    <div>메인 페이지 포함 내용</div>
</section>
</body>
</html>

<html> 자체를 th:replace한다.

<결과 - 페이지 소스 보기>

<!DOCTYPE html>
<html>
<head>
    <title>메인 페이지 타이틀</title>
</head>
<body>
<h1>레이아웃 H1</h1>
<section>
    <p>메인 페이지 컨텐츠</p>
    <div>메인 페이지 포함 내용</div>
</section>
<footer>
    레이아웃 푸터
</footer>
</body>
</html>

정리

웹사이트의 여러 페이지들을 통일해야할 때,

페이지가 적고 단순하다면? -> 템플릿 조각

페이지가 많고 복잡하다면? -> 템플릿 레이아웃

+) 과거 타임리프 2.x에는 템플릿 레이아웃 기능이 없어서 thymeleaf layout dialect와 같은 레이아웃 전용 프레임워크가 필요했다.

그러나 타임리프 3.0에서 템플릿 레이아웃을 지원하면서 전용 프레임워크 없이도 작업이 가능해졌다.

저작자표시 비영리 동일조건

'java > spring' 카테고리의 다른 글

[Spring] ControllerAdvice - 예외 처리 (2)	2023.07.16
[Spring] @SpringBootTest vs @DataJpaTest (0)	2023.07.15
[Spring] DTO의 사용 범위 (0)	2023.06.27
[Spring] Service - 인터페이스 도입과 버저닝 (0)	2023.06.26
[Spring] 의존성 역정 원리(DIP) 관련 용어 (0)	2023.06.23

프로젝트 생성

타임리프 소개

텍스트 - text, utext

변수 - SpringEL

지역 변수

기본 객체들

유틸리티 객체와 날짜

URL 링크

리터럴

연산

속성 값 설정

반복

조건부 평가

주석

블록

자바스크립트 인라인

템플릿 조각

템플릿 레이아웃

'java > spring' 카테고리의 다른 글

티스토리툴바