타임리프의 기본 기능

뚝딱이·2022년 8월 9일
SpringThymeleaf
0

스프링 MVC

목록 보기
11/23

타임리프 소개

서버 사이드 HTML 렌더링 (SSR)

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

Natural Template

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

스프링 통합 지원

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

텍스트 - text, utext

컨트롤러로 넘어온 data엔 Hello Spring!이 들어있다.
이때 타임리프를 사용하여 텍스트를 출력하는 법을 알아보자.

아래와 같이 ${}를 사용하거나, [[${}]]를 사용하는데, ${}는 태그안에서 사용하고, [[${}]]는 컨텐츠 안에서 직접 출력하도록 사용한다. 

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

결과는 아래와 같다.

th:text 사용 Hello Spring!
컨텐츠 안에서 직접 출력하기 = Hello Spring

HTML 문서는 < , > 같은 특수 문자를 기반으로 정의된다. 따라서 뷰 템플릿으로 HTML 화면을 생성할 때는 출력하는 데이터에 이러한 특수 문자가 있는 것을 주의해서 사용해야 한다.

따라서 <b></b>태그를 이용하여 강조를 사용하고 싶다면, 컨트롤러에서 data를 넘겨줄 때 Hello <b>Spring!</b> 와 같은 방법으로 변경해서 넘겨주면 되겠지 라고 생각할 것이다. 하지만, 실제로 소스는 Hello &lt;b&gt;Spring!&lt;/b&gt;와 같은 식으로 넘어오게 된다.

HTML 엔티티

웹 브라우저는 < 를 HTML 테그의 시작으로 인식한다. 따라서 < 를 테그의 시작이 아니라 문자로 표현할 수 있는 방법이 필요한데, 이것을 HTML 엔티티라 한다. 그리고 이렇게 HTML에서 사용하는 특수 문자를 HTML 엔티티로 변경하는 것을 이스케이프(escape)라 한다. 그리고 타임리프가 제공하는 th:text , [[...]] 는 기본적으로 이스케이스(escape)를 제공한다.

따라서 escape를 사용하지 않기 위해서는
th:text 대신 th:utext를, [[...]]대신 [(...)]를 사용하면 된다. 아래의 예제를 보자.

<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>

결과를 보면, 

<h1>text vs utext</h1>
<ul>
  <li>th:text = <span>&lt;b&gt;Hello Spring!&lt;/b&gt;</span></li>
  <li>th:utext = <span><b>Hello Spring!</b></span></li>
</ul>
<h1><span>[[...]] vs [(...)]</span></h1>
<ul>
  <li><span>[[...]] = </span>&lt;b&gt;Hello Spring!&lt;/b&gt;</li>
  <li><span>[(...)] = </span><b>Hello Spring!</b></li>\

와 같이 unescape를 사용하면 Hello Spring이 강조되는 것을 볼 수 있다.

주의) 실제 서비스를 개발하다 보면 escape를 사용하지 않아서 HTML이 정상 렌더링 되지 않는 수 많은 문제가 발생한다. escape를 기본으로 하고, 꼭 필요한 때만 unescape를 사용하자.

변수 - SpringEL

타임리프에서 변수를 사용할 땐 변수 표현식 : ${...}을 사용한다. 

<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>

List의 제일 첫번째 변수를 가져올 때는 위와 같이 작성한다. 

<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>

Map의 userA를 가져와 사용할 땐 위와 같이 작성한다.

th-with를 통해 지역변수를 사용할 수 있다. 

<div th:with="first=${users[0]}">
    <p> 처음 사람의 이름은 <span th:text="${first.username}"></span></p>

기본 객체들

타임리프는 다음의 객체들을 기본으로 제공한다.

  • ${#request}
  • ${#response}
  • ${#session}
  • ${#servletContext}
  • ${#locale}

그런데 #request 는 HttpServletRequest 객체가 그대로 제공되기 때문에 데이터를 조회하려면 request.getParameter("data") 처럼 불편하게 접근해야 한다.

따라서 편의 객체를 제공한다.

  • HTTP 요청 파라미터 접근: param
    예) ${param.paramData}
  • HTTP 세션 접근: session
    예) ${session.sessionData}
  • 스프링 빈 접근: @
    예) ${@helloBean.hello('Spring!')}
<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>

유틸리티 객체와 날짜

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

  • #message : 메시지, 국제화 처리
  • #uris : URI 이스케이프 지원
  • #dates : java.util.Date 서식 지원
  • #calendars : java.util.Calendar 서식 지원
  • #temporals : 자바8 날짜 서식 지원
  • #numbers : 숫자 서식 지원
  • #strings : 문자 관련 편의 기능
  • #objects : 객체 관련 기능 제공
  • #bools : boolean 관련 기능 제공
  • #arrays : 배열 관련 기능 제공
  • #lists , #sets , #maps : 컬렉션 관련 기능 제공
  • #ids : 아이디 처리 관련 기능 제공
<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>

결과는 아래와 같이 나온다. 

<ul>
    <li>default = <span>2022-08-10T02:41:27.526140400</span></li>
    <li>yyyy-MM-dd HH:mm:ss = <span>2022-08-10 02:41:27</span></li>
</ul>
<h1>LocalDateTime - Utils</h1>
<ul>
    <li>${#temporals.day(localDateTime)} = <span>10</span></li>
    <li>${#temporals.month(localDateTime)} = <span>8</span></li>
    <li>${#temporals.monthName(localDateTime)} = <span>8월</span></li>
    <li>${#temporals.monthNameShort(localDateTime)} = <span>8월</span></li>
    <li>${#temporals.year(localDateTime)} = <span>2022</span></li>
    <li>${#temporals.dayOfWeek(localDateTime)} = <span>3</span></li>
    <li>${#temporals.dayOfWeekName(localDateTime)} = <span>수요일</span></li>
    <li>${#temporals.dayOfWeekNameShort(localDateTime)} = <span>수</span></li>
    <li>${#temporals.hour(localDateTime)} = <span>2</span></li>
    <li>${#temporals.minute(localDateTime)} = <span>41</span></li>
    <li>${#temporals.second(localDateTime)} = <span>27</span></li>
    <li>${#temporals.nanosecond(localDateTime)} = <span>526140400</span></li>
</ul>

URL 링크

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

<ul>
    <li><a th:href="@{/hello}">basic url</a></li>
    <li><a th:href="@{/hello(param1=${param1}, param2=${param2})}">hello query param</a></li>
    <li><a th:href="@{/hello/{param1}/{param2}(param1=${param1}, param2=${param2})}">path variable</a></li>
    <li><a th:href="@{/hello/{param1}(param1=${param1}, param2=${param2})}">path variable + query parameter</a></li>
</ul>

  • 단순한 URL
    @{/hello} /hello

  • 쿼리 파라미터
    @{/hello(param1=${param1}, param2=${param2})} /hello?param1=data1&param2=data2
    () 에 있는 부분은 쿼리 파라미터로 처리된다.

  • 경로 변수
    @{/hello/{param1}/{param2}(param1=${param1}, param2=${param2})} /hello/data1/data2
    URL 경로상에 변수가 있으면 () 부분은 경로 변수로 처리된다.

  • 경로 변수 + 쿼리 파라미터
    @{/hello/{param1}(param1=${param1}, param2=${param2})} /hello/data1?param2=data2

  • 상대경로, 절대경로, 프로토콜 기준을 표현할 수 도 있다.

    • /hello : 절대 경로
    • hello : 상대 경로

리터럴

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

<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>

타임리프는 다음과 같은 리터럴이 있다.

  • 문자: 'hello'
  • 숫자: 10
  • boolean : true , false
    null: null
    타임리프에서 문자 리터럴은 항상 ' (작은 따옴표)로 감싸야 한다.

그런데 문자를 항상 ' 로 감싸는 것은 너무 귀찮은 일이다. 공백 없이 쭉 이어진다면 하나의 의미있는 토큰으로 인지해서 다음과 같이 작은 따옴표를 생략할 수 있다.
룰: A-Z , a-z , 0-9 , [] , . , - , _
예를 들어<span th:text="hello">와 같이 한번에 이어진 hello는 작은 따옴표를 생략해 사용할 수 있다.

하지만 맨위의 예제에서 주석을 풀면 예외가 발생하는 이유는 hello world!가 한번에 이어진 문자도 아닌데 작은 따옴표를 생략했기 때문이다. 매우 흔히 발생하는 실수이기 때문에 주의하자.

예제의 맨 아래줄 같이 <span th:text="|hello ${data}|"> 리터럴 대체를 사용하면 +기호를 붙이지 않아도돼 편리하다.

연산

    <li>산술 연산
        <ul>
            <li>10 + 2 = <span th:text="10 + 2"></span></li>
            <li>10 % 2 == 0 = <span th:text="10 % 2 == 0"></span>		</li>

비교연산: HTML 엔티티를 사용해야 하는 부분을 주의해야한다.

(gt), < (lt), >= (ge), <= (le), ! (not), == (eq), != (neq, ne)

    <li>비교 연산
        <ul>
            <li>1 > 10 = <span th:text="1 &gt; 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>

JAVA의 조건식과 유사하다. 

    <li>조건식
        <ul>
            <li>(10 % 2 == 0)? '짝수':'홀수' = <span th:text="(10 % 2 == 0)?'짝수':'홀수'"></span></li>
        </ul>
    </li>

Elvis 연산자: 조건식의 편의 버전

    <li>Elvis 연산자
        <ul>
            <li>${data}?: '데이터가 없습니다.' = <span th:text="${data}?: '데이터가 없습니다.'"></span></li>
            <li>${nullData}?: '데이터가 없습니다.' = <span th:text="${nullData}?:'데이터가 없습니다.'"></span></li>
        </ul>
    </li>

No-Operation: _ 인 경우 마치 타임리프가 실행되지 않는 것 처럼 동작한다. 이것을 잘 사용하면 HTML의 내용 그대로 활용할 수 있다. 마지막 예를 보면 데이터가 없습니다. 부분이 그대로 출력된다.

    <li>No-Operation
        <ul>
            <li>${data}?: _ = <span th:text="${data}?: _">데이터가 없습니다.</span></li>
            <li>${nullData}?: _ = <span th:text="${nullData}?: _">데이터가 없습니다.</span></li>
        </ul>
    </li>

속성 값 설정

<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: 속성을 지정하는 방식으로 동작한다. th: 로 속성을 적용하면 기존 속성을 대체한다. 기존 속성이 없으면 새로 만든다

<input type="text" name="mock" th:name="userA" /> 부분이 타임리프 렌더링 후 <input type="text" name="userA" />로 변경된다.

속성 추가

  • th:attrappend : 속성 값의 뒤에 값을 추가한다.
  • th:attrprepend : 속성 값의 앞에 값을 추가한다.
  • th:classappend : class 속성에 자연스럽게 추가한다.

checked 처리

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

HTML에서 checked 속성은 checked 속성의 값과 상관없이 checked 라는 속성만 있어도 체크가 된다.

이런 부분이 true , false 값을 주로 사용하는 개발자 입장에서는 불편하다. 개발자는 boolean을 많이 쓰기 때문에 로직이 번잡해지기 때문이다.
타임리프의 th:checked 는 값이 false 인 경우 checked 속성 자체를 제거한다.
따라서 <input type="checkbox" name="active" th:checked="false" />가
타임리프 렌더링 후: <input type="checkbox" name="active" />로 변경된다.

반복

타임리프에서 반복은 th:each 를 사용한다. 추가로 반복에서 사용할 수 있는 여러 상태 값을 지원한다.

<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>

와 같이 사용하면 결과로 

<h1>기본 테이블</h1>
<table border="1">
    <tr>
        <th>username</th>
        <th>age</th>
    </tr>
    <tr>
        <td>UserA</td>
        <td>10</td>
    </tr>
    <tr>
        <td>UserB</td>
        <td>20</td>
    </tr>
    <tr>
        <td>UserC</td>
        <td>30</td>
    </tr>

가 작성된다.

반복시 오른쪽 컬렉션( ${users} )의 값을 하나씩 꺼내서 왼쪽 변수( user )에 담아서 태그를 반복 실행한다.
th:each 는 List 뿐만 아니라 배열, java.util.Iterable , java.util.Enumeration 을 구현한 모든 객체를 반복에 사용할 수 있다. Map 도 사용할 수 있는데 이 경우 변수에 담기는 값은 Map.Entry이다.

반복 상태 유지

<tr th:each="user, userStat : ${users}">
반복의 두번째 파라미터를 설정해서 반복의 상태를 확인 할 수 있다.
두번째 파라미터는 생략 가능한데, 생략하면 지정한 변수명( user ) + Stat 가 된다.
여기서는 user + Stat = userStat 이므로 생략 가능하다.

반복 상태 유지 기능

  • index : 0부터 시작하는 값
  • count : 1부터 시작하는 값
  • size : 전체 사이즈
  • even , odd : 홀수, 짝수 여부( boolean )
  • first , last :처음, 마지막 여부( boolean )
  • current : 현재 객체
</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>

결과는 아래와 같다.

count username age etc
1 UserA 10 index = 0 count = 1 size = 3 even? = false odd? = true first? = true last? = false current = BasicController.User(username=UserA, age=10)
2 UserB 20 index = 1 count = 2 size = 3 even? = true odd? = false first? = false last? = false current = BasicController.User(username=UserB, age=20)
3 UserC 30 index = 2 count = 3 size = 3 even? = false odd? = true first? = false last? = true current = BasicController.User(username=UserC, age=30) 
</table><h1>반복 상태 유지</h1>
<table border="1">
    <tr>
        <th>count</th>
        <th>username</th>
        <th>age</th>
        <th>etc</th>
    </tr>
    <tr>
        <td>1</td>
        <td>UserA</td>
        <td>10</td>
        <td>
            index = <span>0</span>
            count = <span>1</span>
            size = <span>3</span>
            even? = <span>false</span>
            odd? = <span>true</span>
            first? = <span>true</span>
            last? = <span>false</span>
            current = <span>BasicController.User(username=UserA, age=10)</span>
        </td>
    </tr>
    <tr>
        <td>2</td>
        <td>UserB</td>
        <td>20</td>
        <td>
            index = <span>1</span>
            count = <span>2</span>
            size = <span>3</span>
            even? = <span>true</span>
            odd? = <span>false</span>
            first? = <span>false</span>
            last? = <span>false</span>
            current = <span>BasicController.User(username=UserB, age=20)</span>
        </td>
    </tr>
    <tr>
        <td>3</td>
        <td>UserC</td>
        <td>30</td>
        <td>
            index = <span>2</span>
            count = <span>3</span>
            size = <span>3</span>
            even? = <span>false</span>
            odd? = <span>true</span>
            first? = <span>false</span>
            last? = <span>true</span>
            current = <span>BasicController.User(username=UserC, age=30)</span>
        </td>
    </tr>
</table>

조건부 평가

타임리프의 조건부는 if , unless를 사용한다.

만약 if구문이 true라면 text구문을 출력한다.
unless는 if와 반대로 작동한다.

타임리프는 해당 조건이 맞지 않으면 태그 자체를 렌더링하지 않는다.
만약 조건이 false 인 경우 태그 자체가 렌더링 되지 않고 사라진다.

<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>

switch문도 사용가능하다. * 은 만족하는 조건이 없을 때 사용하는 디폴트이다.


<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>

주석

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

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

  3. 타임리프 프로토타입 주석
    타임리프 프로토타입은 약간 특이한데, HTML 주석에 약간의 구문을 더했다.
    HTML 파일을 웹 브라우저에서 그대로 열어보면 HTML 주석이기 때문에 이 부분이 웹 브라우저가 렌더링하지 않는다.
    타임리프 렌더링을 거치면 이 부분이 정상 렌더링 된다.
    쉽게 이야기해서 HTML 파일을 그대로 열어보면 주석처리가 되지만, 타임리프를 렌더링 한 경우에만 보이는 기능이다.

<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>
/*/-->

결과로 서버를 실행한 소스는 다음과 같다. 

<span>Spring!</span>
<h1>1. 표준 HTML 주석</h1>
<!--
<span th:text="${data}">html data</span>-->
<h1>2. 타임리프 파서 주석</h1>


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

<span>Spring!</span>

거의 파서주석을 사용한다.

블록

<th:block> 은 HTML 태그가 아닌 타임리프의 유일한 자체 태그다.<th:block> 은 렌더링시 제거된다.

<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>

each만으로 해결하기 어려울 때, 애매할 때 사용한다. 별로 권장하진 않는데 어쩔 수 없이 써야하는 경우가 온다.

자바스크립트 인라인

타임리프는 자바스크립트에서 타임리프를 편리하게 사용할 수 있는 자바스크립트 인라인 기능을 제공한다.
자바스크립트 인라인 기능은 다음과 같이 적용하면 된다.
<script th:inline="javascript">

<!-- 자바스크립트 인라인 사용 전 -->
<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>

결과는 아래와 같다. 

<!-- 자바스크립트 인라인 사용 전 -->
<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>

텍스트 렌더링

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

  • 인라인 사용 전 : var username = userA;
  • 인라인 사용 후 : var username = "userA";
    인라인 사용 전 렌더링 결과를 보면 userA 라는 변수 이름이 그대로 남아있다. 타임리프 입장에서는 정확하게 렌더링 한 것이지만 아마 개발자가 기대한 것은 다음과 같은 "userA"라는 문자일 것이다.
    결과적으로 userA가 변수명으로 사용되어서 자바스크립트 오류가 발생한다. 다음으로 나오는 숫자 age의 경우에는 " 가 필요 없기 때문에 정상 렌더링 된다.
    인라인 사용 후 렌더링 결과를 보면 문자 타입인 경우 " 를 포함해준다. 추가로 자바스크립트에서 문제가 될 수 있는 문자가 포함되어 있으면 이스케이프 처리도 해준다. 예) " \"

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

자바스크립트 인라인 기능을 사용하면 주석을 활용해서 natural template 기능을 사용할 수 있다.
var username2 = /*[[${user.username}]]*/ "test username";

  • 인라인 사용 전 : var username2 = /*userA*/ "test username";
  • 인라인 사용 후 : var username2 = "userA";
    인라인 사용 전 결과를 보면 정말 순수하게 그대로 해석을 해버렸다. 따라서 내추럴 템플릿 기능이 동작하지 않고, 심지어 렌더링 내용이 주석처리 되어 버린다. 인라인 사용 후 결과를 보면 주석 부분이 제거되고, 기대한 "userA"가 정확하게 적용된다.

객체

타임리프의 자바스크립트 인라인 기능을 사용하면 객체를 JSON으로 자동으로 변환해준다.
var user = [[${user}]];

  • 인라인 사용 전 var user = BasicController.User(username=userA, age=10);
    객체의 toString()이 호출된다.
  • 인라인 사용 후 var user = {"username":"userA","age":10};
    객체를 JSON으로 변환해준다.

each

<script th:inline="javascript">
    [# th:each="user, stat : ${users}"]
    var user[[${stat.count}]] = [[${user}]];
    [/]
</script>
<script>
    
    var user1 = {"username":"UserA","age":10};
    var user2 = {"username":"UserB","age":20};
    var user3 = {"username":"UserC","age":30};
    
</script>

인라인을 사용하면 JSON 형태로 출력되므로 each를 사용했을 때도 JSON형태로 출력된것을 볼 수 있다.

웹 페이지를 개발할 때는 공통 영역이 많이 있다. 예를 들어서 상단 영역이나 하단 영역, 좌측 카테고리 등등 여러 페이지에서 함께 사용하는 영역들이 있다. 이런 부분을 코드를 복사해서 사용한다면 변경시 여러 페이지를 다 수정해야 하므로 상당히 비효율 적이다. 타임리프는 이런 문제를 해결하기 위해 템플릿 조각과 레이아웃 기능을 지원한다.

템플릿 조각

부분 포함 insert

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

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

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

위와 같이 <div>안에 가져온 템플릿 조각이 존재한다.

부분 포함 replace

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

위와 똑같이 copy를 템플릿 조각으로 가져와서 사용했다. 

<footer>
    푸터 자리 입니다.
</footer>

하지만 결과를 보면, <div>안에 템플릿 조각이 존재하는 것이 아닌 <div> 태그 자체가 템플릿 조각으로 대체되었다.

부분 포함 표현식

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

~{...} 를 사용하는 것이 원칙이지만 템플릿 조각을 사용하는 코드가 단순하면 이 부분을 생략할 수 있다.

파라미터 사용

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

파라미터를 넣어 사용할 수도 있다.

템플릿 레이아웃

<head> 에 공통으로 사용하는 css , javascript 같은 정보들이 있는데, 이러한 공통 정보들을 한 곳에 모아두고, 공통으로 사용하지만, 각 페이지마다 필요한 정보를 더 추가해서 사용하고 싶다면 다음과 같이 사용하면 된다.

내 정보

<!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>

공통 정보

<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>

위와 같이 작성하면 아래와 같은 결과가 나온다.

<!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>

공통정보는 그대로 가져오고 param으로 넘겨준 title과 link들은 내 정보에서 사용한 것을 확인할 수 있다.

common_header(~{::title},~{::link})

  • ::title 은 현재 페이지의 title 태그들을 전달한다.
  • ::link 는 현재 페이지의 link 태그들을 전달한다.

<head> 정도에만 적용하는게 아니라 <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>

공통정보

<!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>

결과

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

html을 통째로 가져와 사용했다. title과 content만 내 정보를 사용한 것을 확인할 수 있다.

엄청난 개수의 html이 일정한 모양을 가지고 있을 때 사용하면 편리하다. 하지만 개수가 그렇게 많지 않다면 fragment를 사용하자.

레이아웃의 장점은 여러 html의 수정사항이 있을 때 한번에 수정이 가능한 등 체계적인 것이지만 이는 곧 단점이 되기도 한다.

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

profile
뚝딱이
백엔드 개발자 지망생
이전 포스트

스프링 MVC 웹페이지 만들기

다음 포스트

타임리프 - 스프링 통합과 폼

0개의 댓글