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

영우·약 16시간 전
MVCSpringThymeleaf

타임리프 소개

타임리프 소개

타임리프 특징

  • 서버 사이드 HTML 렌더링 (SSR)
  • 네츄럴 템플릿
  • 스프링 통합 지원

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

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

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

타임리프 기본 기능

타임리프 사용 선언
<html xmlns:th="http://www.thymeleaf.org">

텍스트 - text, utext

텍스트 - text, utext

타임리프는 기본적으로 HTML 테그의 속성에 기능을 정의해서 동작한다.
HTML의 콘텐츠(content)에 데이터를 출력할 때는 다음과 같이 th:text 를 사용하면 된다.
<span th:text="${data}">

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

BasicController

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

  @GetMapping("/text-basic")
  public String textBasic(Model model) {
    model.addAttribute("data", "Hello Spring!");
    return "basic/text-basic";
  }
}
<!DOCTYPE html>
<html xmlns: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>

Escape

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

변경 전
"Hello Spring!"

변경 후
"Hello <b>Spring!</b>"

<b> 태그를 사용해서 Spring!이라는 단어가 진하게 나오도록 해보자.

  • 웹 브라우저: Hello <b>Spring!</b>
  • 소스보기: Hello &lt;b&gt;Spring!&lt;/b&gt;

개발자가 의도한 것은 <b> 가 있으면 해당 부분을 강조하는 것이 목적이었다. 그런데 <b> 테그가 그대로 나온다.
소스보기를 하면 < 부분이 &lt;로 변경된 것을 확인할 수 있다.

Unescape

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

  • th:text th:utext
  • [[...]] [(...)]

변수 - SpringEL

변수 - SpringEL

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

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
public static class User {
  private String username;
  private int age;
  
  public User(String username, int age) {
    this.username = username;
    this.age = age;
  }
}

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

SpringEL 다양한 표현식 사용

Object

  • user.username : user의 username을 프로퍼티 접근 -> user.getUsername()
  • user['username'] : 위와 같음 -> user.getUsername()
  • user.getUsername() : user의 getUsername() 을 직접 호출

List

  • users[0].username : List에서 첫 번째 회원을 찾고 username 프로퍼티 접근 -> list.get(0).getUsername()
  • users[0]['username'] : 위와 같음
  • users[0].getUsername() : List에서 첫 번째 회원을 찾고 메서드 직접 호출

Map

  • userMap['userA'].username : Map에서 userA를 찾고, username 프로퍼티 접근 -> map.get("userA").getUsername()
  • userMap['userA']['username'] : 위와 같음
  • userMap['userA'].getUsername() : Map에서 userA를 찾고 메서드 직접 호출

지역 변수 선언

th:with 를 사용하면 지역 변수를 선언해서 사용할 수 있다. 지역 변수는 선언한 태그 안에서만 사용할 수 있다.

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

기본 객체들

BasicController 추가

@GetMapping("/basic-objects")
public String basicObjects(Model model, HttpServletRequest request,
  HttpServletResponse response, HttpSession session) {
    session.setAttribute("sessionData", "Hello Session");
    model.addAttribute("request", request);
    model.addAttribute("response", response);
    model.addAttribute("servletContext", request.getServletContext());
  return "basic/basic-objects";
}

@Component("helloBean")
static class HelloBean {
  public String hello(String data) {
    return "Hello " + data;
  }
}
<!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>
  • HTTP 요청 파라미터 접근: param
    • 예) ${param.paramData}
  • HTTP 세션 접근: session
    • 예) ${session.sessionData}
  • 스프링 빈 접근: @
    • 예) ${@helloBean.hello('Spring!')}

URL 링크

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

BasicController 추가

@GetMapping("/link")
public String link(Model model) {
  model.addAttribute("param1", "data1");
  model.addAttribute("param2", "data2");
  
  return "basic/link";
}
<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
  <meta charset="UTF-8">
  <title>Title</title>
</head>
<body>
<h1>URL 링크</h1>
<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>
</body>
</html>

단순한 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" 는 문자 리터럴, 10 , 20 는 숫자 리터럴이다.

String a = "Hello"
int a = 10 * 20

타임리프에서 문자 리터럴은 항상 작은 따옴표로 감싸야한다.
<span th:text="'hello'">

그런데 문자를 항상 작은 따옴표로 감싸는 것은 너무 귀찮은 일이다.
공백 없이 쭉 이어진다면 하나의 의미있는 토큰으로 인지해서 작은 따옴표를 생략할 수 있다.

<span th:text="hello">

오류
<span th:text="hello world!"></span>
문자 리터럴은 원칙상 '로 감싸야 한다. 중간에 공백이 있어서 하나의 의미있는 토큰으로도 인식되지 않는다.

수정
<span th:text="'hello world!'"></span>
이렇게 '로 감싸면 정상 동작한다.

BasicController 추가

@GetMapping("/literal")
public String literal(Model model) {
  model.addAttribute("data", "Spring!");
  return "basic/literal";
}
<ul>
  <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>

<span th:text="|hello ${data}|">
마지막의 리터럴 대체 문법을 사용하면 마치 템플릿을 사용하는 것 처럼 편리하다.

연산

타임리프 연산은 자바와 크게 다르지 않다. HTML안에서 사용하기 때문에 HTML 엔티티를 사용하는 부분만 주의하자.

<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 &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>
<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>
  • 비교연산: HTML 엔티티를 사용해야 하는 부분을 주의하자
    • > (gt), < (lt), >= (ge), <= (le), ! (not), == (eq), != (neq, ne)
  • 조건식: 자바의 조건식과 유사하다.
  • Elvis 연산자: 조건식의 편의 버전
  • No-Operation: _ 인 경우 마치 타임리프가 실행되지 않는 것 처럼 동작한다. 이것을 잘 사용하면 HTML의 내용 그대로 활용할 수 있다. 마지막 예를 보면 데이터가 없습니다. 부분이 그대로 출력된다.

속성 값 설정

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

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

속성 설정
th* 속성을 지정하면 타임리프는 기존 속성을 th*로 지정한 속성으로 대체한다. 기존 속성이 없으면 새로 만든다.
<input type="text" name="mock" th:name="userA" />
-> 타임리프 렌더링 후 <input type="text" name="userA" />

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

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

HTML에서 checked 속성은 checked 속성의 값과 상관없이 checked 라는 속성만 있어도 체크가 된다. 이런 부분이 true , false 값을 주로 사용하는 개발자 입장에서는 불편하다.

타임리프의 th:checked 는 값이 false 인 경우checked 속성 자체를 제거한다.
<input type="checkbox" name="active" th:checked="false" />
-> 타임리프 렌더링 후: <input type="checkbox" name="active" />

반복

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

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);
}
<h1>기본 테이블</h1>
<table border="1">
  <tr th:each="user : ${users}">
    <td th:text="${user.username}">username</td>
    <td th:text="${user.age}">0</td>
  </tr>
</table>

<table border="1">
  <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>

반복 기능
<tr th:each="user : ${users}">

  • 반복시 오른쪽 컬렉션(${users} )의 값을 하나씩 꺼내서 왼쪽 변수(user )에 담아서 태그를 반복 실행합니다.

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

반복 상태 유지 기능

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

조건

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

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

if, unless
타임리프는 해당 조건이 맞지 않으면 태그 자체를 렌더링하지 않는다.
만약 다음 조건이 false 인 경우 <span>...<span> 부분 자체가 렌더링 되지 않고 사라진다.
<span th:text="'미성년자'" th:if="${user.age lt 20}"></span>

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

주석

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

결과

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

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

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

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

3. 타임리프 프로토타입 주석
HTML 파일을 웹 브라우저에서 그대로 열어보면 HTML 주석이기 때문에 이 부분이 웹 브라우저가 렌더링하지 않는다.
타임리프 렌더링을 거치면 이 부분이 정상 렌더링 된다.

블록

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

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

실행 결과

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

자바스크립트 인라인

타임리프는 자바스크립트에서 타임리프를 편리하게 사용할 수 있는 자바스크립트 인라인 기능을 제공한다.
<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가 변수명으로 사용되어서 자바스크립트 오류가 발생한다.
  • 인라인 사용 후 렌더링 결과를 보면 문자 타입인 경우 " 를 포함해준다.

자바스크립트 내추럴 템플릿
타임리프는 HTML 파일을 직접 열어도 동작하는 내추럴 템플릿 기능을 제공한다.

  • var username2 = /*[[${user.username}]]*/ "test username";
    • 인라인 사용전 -> var username2 = /*userA*/ "test username";
    • 인라인 사용후 -> var username2 = "userA";

객체
타임리프의 자바스크립트 인라인 기능을 사용하면 객체를 JSON으로 자동으로 변환해준다.

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

    • 인라인 사용전 -> var user = BasicController.User(username=userA, age=10);
    • 인라인 사용후 -> var user = {"username":"userA","age":10};

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

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

자바스크립트 인라인 each

자바스크립트 인라인은 each를 지원하는데, 다음과 같이 사용한다.

<!-- 자바스크립트 인라인 each -->
<script th:inline="javascript">
  [# th:each="user, stat : ${users}"]
  var user[[${stat.count}]] = [[${user}]];
  [/]
</script>

자바스크립트 인라인 each 결과

<script>
var user1 = {"username":"userA","age":10};
var user2 = {"username":"userB","age":20};
var user3 = {"username":"userC","age":30};
</script>
profile
영우
이전 포스트

[Spring] 커넥션풀과 데이터소스 이해

다음 포스트

[Spring] 타임리프 - 스프링 통합과 폼

0개의 댓글