💫 JPA

• JPA: 자바 객체와 관계형 데이터베이스를 매핑하는 표준 API
• ORM(Object‑Relational Mapping): 객체 지향 모델과 RDB 테이블 간 변환 책임
• Persistence Context: 1차 캐시로 엔티티 상태 관리
• EntityManager: 영속성 작업의 진입점
• 주요 어노테이션: @Entity, @Id, @Column, @OneToMany 등
• JPQL: SQL처럼 보이지만 엔티티를 대상으로 쿼리 작성 가능

어노테이션	설명
@Entity	엔티티 클래스로 표시
@Table(name=)	테이블 명 지정
@Id	기본 키 필드 지정
@GeneratedValue	키 자동 생성 전략 지정
@Column	컬럼 매핑 속성(이름, 널 허용 등)
@ManyToOne	N:1 연관 매핑 (외래키)
@OneToMany	1:N 연관 매핑 (mappedBy 사용)
@JoinColumn	FK 컬럼 명 지정
@Embedded	값 타입(내장 객체) 매핑

---

🏁 Simple_board with JPA

🌿simple_board.git

✅ 실습 의존성 목록

Spring Boot DevTools Developer Tools
Provides fast application restarts, LiveReload, and configurations for enhanced development experience.

Lombok Developer Tools
Java annotation library which helps to reduce boilerplate code.

Spring Web Web
Build web, including RESTful, applications using Spring MVC. Uses Apache Tomcat as the default embedded container.

Thymeleaf Template Engines
A modern server-side Java template engine for both web and standalone environments. Allows HTML to be correctly displayed in browsers and as static prototypes.

Spring Data JPA SQL
Persist data in SQL stores with Java Persistence API using Spring Data and Hibernate.

PostgreSQL Driver SQL
A JDBC and R2DBC driver that allows Java programs to connect to a PostgreSQL database using standard, database independent Java code.

Validation I/O
Bean Validation with Hibernate validator.

---

✅ PostgreSql 공간 만들어주기
JPA가 자동으로 테이블을 생성해 주기는 하는데, 우선 postgres에서 유저와 데이터베이스 공간은 만들어 주어야 한다.

psql -U postgres
CREATE USER simple_board WITH PASSWORD 'password';
CREATE DATABASE simple_board OWNER simple_board;

🧠 model.User.java

@Entity
@Table(name="users")
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class User {
    // 기본 키(primary key) 필드로 지정
    @Id

    // 기본 키를 DB에서 자동 증가시키도록 설정.
    // PostgreSQL의 SERIAL 또는 IDENTITY 컬럼과 호환됨
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;

    // username 컬럼 설정:
    // - null 불허 (NOT NULL)
    // - 유일한 값이어야 함 (UNIQUE)
    // - 최대 길이 50자 (VARCHAR(50))
    // PostgreSQL에서는 VARCHAR(n)으로 자동 매핑됨
    @Column(nullable = false, unique = true, length = 50)
    private String username;
}

col	desc
id	GenerationType.IDENTITY를 사용함으로써 AUTO_INCREMENT 와 동일한 효과
username	널값 제외 / 유니크를 달아줘야 atomic해짐 / 프론트단과 별개로 db에서도 길이 잡아줘야함.

---

✅ 몇개의 어노테이션 만으로 JPA가 테이블 생성을 해준다. db에서 확인해 보자.

먼저 db 연결 설정
application.yml

spring:
  application:
    name: simple_board
  datasource:
    url: jdbc:postgresql://${DB_HOST}:${DB_PORT}/${DB_NAME}
    username: ${DB_USERNAME}
    password: ${DB_PASSWORD}
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true

✅ 쉘에서 확인해보면 따로 테이블 생성 쿼리를 입력하지 않았는데 db에 테이블이 만들어진 것을 확인할 수 있다.

psql -U simple_board
simple_board=> \dt
             릴레이션 목록
 스키마 | 이름  |  형태  |    소유주
--------+-------+--------+--------------
 public | users | 테이블 | simple_board
(1개 행)

🧠 model.Post.java

@Entity
@Table(name="posts")
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class Post {

    // 기본 키로 지정. 각 게시글의 고유 식별자
    @Id
    // PostgreSQL에서 IDENTITY 전략을 사용하여 자동 증가 (SERIAL/IDENTITY)
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;

    // 게시글 제목 컬럼 설정
    // - null 불가 (NOT NULL)
    // - 최대 200자 (VARCHAR(200))
    @Column(nullable = false, length = 200)
    private String title;

    // 게시글 내용 컬럼 설정
    // - null 불가 (NOT NULL)
    // - 길이 제한 없음 → PostgreSQL에서는 TEXT 타입으로 매핑될 수 있음
    @Column(nullable=false)
    private String content;

    // 작성 시간 컬럼
    // - null 불가 (NOT NULL)
    // - Java LocalDateTime은 PostgreSQL의 TIMESTAMP로 매핑됨
    @Column(nullable = false)
    private LocalDateTime createdAt;

    // 작성자와의 다대일 관계 (N:1)
    // - 하나의 유저(User)가 여러 개의 게시글(Post)을 작성할 수 있음
    // - 지연 로딩: 실제 사용할 때 로딩됨 (성능 최적화)
    // - optional=false: 반드시 author가 있어야 함 (NOT NULL)
    @ManyToOne(fetch = FetchType.LAZY, optional = false)
    
    // 외래 키 설정
    // - posts 테이블의 author_id 컬럼이 users 테이블의 id 컬럼을 참조
    @JoinColumn(name="author_id")
    private User author; // user_id

    // 댓글과의 일대다 관계 (1:N)
    // - 하나의 게시글(Post)이 여러 개의 댓글(Comment)을 가질 수 있음
    // - mappedBy="post": Comment 엔티티의 post 필드가 외래 키 주인
    // - cascade = ALL: 게시글을 저장/삭제할 때 댓글도 함께 저장/삭제됨
    // - orphanRemoval = true: 댓글이 관계에서 제거되면 DB에서도 삭제됨
    @OneToMany(mappedBy = "post", cascade = CascadeType.ALL, orphanRemoval = true)
    
    // 댓글 정렬 기준 지정
    // - createdAt 오름차순으로 정렬된 상태로 comments 리스트에 담김
    @OrderBy("createdAt ASC")
    private List<Comment> comments;
}

col	desc
id	strategy = GenerationType.IDENTITY 로 atomic 값 생성
title	우선 length로 막아주긴 하는데 valid 에러처리는 리포지토리에서
author	- post 조회 -> user data 자동으로 조회 - lazy는 초반에는 user는 null 값을 줬다가 필요하면 조회해서 준다. 일반적으로 lazy를 기본으로 쓴다. - optional false : 필수 - @JoinColumn 만 쓰면 user_id 컬럼이 생성되는데 post 관점에서 user는 author 이므로 author_id 로 생성

🧠 model.Comment.java

@Entity // 이 클래스가 JPA 엔티티임을 명시. DB 테이블과 매핑됨
@Table(name = "comments") // 매핑될 테이블 이름을 "comments"로 지정
@Data // Lombok: getter, setter, toString, equals, hashCode, requiredArgsConstructor 자동 생성
@NoArgsConstructor // Lombok: 기본 생성자 생성
@AllArgsConstructor // Lombok: 모든 필드를 파라미터로 갖는 생성자 생성
@Builder // Lombok: 빌더 패턴 사용 가능
public class Comment {

    @Id // 기본 키(primary key) 필드로 지정
    @GeneratedValue(strategy = GenerationType.IDENTITY) 
    // PostgreSQL에서 IDENTITY 전략 사용 → SERIAL/IDENTITY로 자동 증가
    private Integer id;

    @Column(nullable = false)
    // 댓글 내용은 null을 허용하지 않음 → NOT NULL
    private String text;

    @Column(nullable = false)
    // 댓글 작성 시각, null 불가 → NOT NULL
    // LocalDateTime은 PostgreSQL에서 TIMESTAMP로 매핑됨
    private LocalDateTime createdAt;

    @ManyToOne(fetch = FetchType.LAZY, optional = false)
    // 댓글과 작성자(User) 간의 다대일(N:1) 관계
    // 지연 로딩 설정 (필요할 때까지 author 로딩 지연)
    // optional = false → 작성자는 반드시 존재해야 함
    @JoinColumn(name = "author_id")
    // 외래 키 이름을 author_id로 지정 (users 테이블의 id 참조)
    private User author;

    @ManyToOne(fetch = FetchType.LAZY, optional = false)
    // 댓글과 게시글(Post) 간의 다대일(N:1) 관계
    // 하나의 게시글에 여러 댓글이 달릴 수 있음
    @JoinColumn(name = "post_id")
    // 외래 키 이름을 post_id로 지정 (posts 테이블의 id 참조)
    private Post post;
}

Repository는 인터페이스로 만들고 JpaRepository를 상속만 해주면 JPA가 자동으로 CRUD를 구현해준다. 와 마법! 만약 class로 쓰면 실행은 되지만 jpa 기능 못쓴다.
🗄️ UserRepository

// User 엔티티를 관리하는 JPA 리포지토리 인터페이스
// - JpaRepository<엔티티 타입, 기본 키 타입>을 상속받음
// - 기본적인 CRUD 메서드들이 자동으로 구현됨
public interface UserRepository extends JpaRepository<User, Integer> {

    // username 컬럼으로 유저를 조회하는 커스텀 메서드
    // - Optional로 감싸 null-safe하게 처리 (조회 결과 없을 경우 : null)
    // - 메서드 이름 기반 쿼리 생성 (Spring Data JPA가 자동 구현)
    Optional<User> findByUsername(String username);
}

🗄️ PostRepository

// Post 엔티티를 관리하는 JPA 리포지토리 인터페이스
// - 기본 CRUD 외에 필요시 커스텀 쿼리 추가 가능
public interface PostRepository extends JpaRepository<Post, Integer> {
}

🗄️ CommentRepository

// Comment 엔티티를 관리하는 JPA 리포지토리 인터페이스
// - 모든 댓글 관련 DB 작업을 추상화
public interface CommentRepository extends JpaRepository<Comment, Integer> {
}

✅ JPA가 내부적으로 동작하는 과정

1. 쿼리 생성

• JPA는 메서드 이름을 기반으로 쿼리를 생성한다. (Query Derivation)

Optional<User> findByUsername(String username);

SELECT u FROM User u WHERE u.username = :username

2. Spring이 내부적으로 프록시 클래스 생성

• Spring 부팅 시점에 Spring은 UserRepository를 구현한 프록시 객체를 자동으로 생성한다.
• 그 프록시 객체는 SimpleJpaRepository라는 내부 구현체를 기반으로 만들어진다.
• 그리고 EntityManager를 통해 DB에 접근한다.

UserRepository → (프록시) → SimpleJpaRepository → EntityManager (JPA)

3. 만약 메서드 이름만으로 복잡한 조건을 처리하기 어렵다면
   이렇게 @Query 어노테이션으로 JPQL 직접 작성도 가능하다.

@Query("SELECT p FROM Post p WHERE p.title LIKE %:keyword%")
List<Post> searchByTitle(@Param("keyword") String keyword);

---

@Getter
@Setter
public class SignupDto {
    @NotBlank
    @Size(min=3, max=50)
    private String username;

    @NotBlank
    @Size(min=6, max=1000)
    private String password;
}

@Getter
@Setter
public class LoginDto {
    @NotBlank(message="아이디를 입력하세요")
    private String username;

    @NotBlank(message="비밀번호를 입력하세요")
    private String password;
}

@Getter
@Setter
public class PostDto {
    private Integer id;

    @NotBlank(message = "제목을 입력하세요")
    private String title;

    @NotBlank(message = "내용을 입력하세요")
    private String content;
}

// 이 클래스가 Spring MVC의 컨트롤러임을 나타냄 (요청-응답 처리 담당)
@Controller

// final이 붙은 필드(userRepository)에 대해 생성자를 자동으로 생성 (Lombok)
@RequiredArgsConstructor
public class SignupController {

    // DI(의존성 주입) 대상: UserRepository 주입됨
    private final UserRepository userRepository;

    // 회원가입 폼 페이지를 보여주는 GET 요청 처리
    @GetMapping("/signup") // GET 방식 /signup 요청이 들어오면 이 메서드 실행
    public String signupForm(Model model) {
        // signup.html에서 사용할 signupDto 객체를 모델에 등록
        model.addAttribute("signupDto", new SignupDto());
        // 뷰 이름 반환 → templates/signup.html 렌더링
        return "signup";
    }

    // 회원가입 폼 제출 처리 (POST 요청)
    @PostMapping("/signup") // POST 방식 /signup 요청 시 이 메서드 실행
    public String signup(
            // 클라이언트에서 넘어온 form 데이터를 SignupDto에 바인딩
            // - name="username" → signupDto.setUsername(...)
            // - name="password" → signupDto.setPassword(...)
            // @Valid: DTO에 설정된 유효성 검사 어노테이션(@NotBlank 등)을 수행함
            @Valid @ModelAttribute SignupDto signupDto,

            // 바인딩/검증 결과가 저장됨. 유효성 검사에 실패하면 오류 정보가 여기에 들어감
            BindingResult bindingResult,

            // 모델에 에러 메시지를 담기 위해 전달받음
            Model model
    ) {
        // 유효성 검사 실패 시 다시 signup.html 페이지로 이동 (오류 메시지 출력용)
        if(bindingResult.hasErrors()) return "signup";

        // username 중복 검사
        if(userRepository.findByUsername(signupDto.getUsername()).isPresent()) {
            // 모델에 에러 메시지 추가
            model.addAttribute("error", "이미 사용중인 아이디입니다");
            // 다시 회원가입 폼 보여줌
            return "signup";
        }

        // 회원 정보 저장 (비밀번호는 실제 서비스에선 반드시 암호화 필요!)
        userRepository.save(
                User.builder()
                        .username(signupDto.getUsername())
                        .password(signupDto.getPassword()) // 암호화 생략됨
                        .build()
        );

        // 회원가입 성공 시 로그인 페이지로 리다이렉트 (URL 뒤에 ?registered 쿼리 파라미터 추가)
        return "redirect:/login?registered";
    }
}

어노테이션 / 클래스	설명
@Controller	Spring MVC의 컨트롤러 지정. 반환값은 뷰 이름으로 해석됨
@GetMapping, @PostMapping	HTTP GET/POST 요청을 해당 메서드와 매핑
@ModelAttribute	폼 데이터 → DTO 객체로 바인딩
@Valid	DTO에 설정된 유효성 검사(@NotNull, @Size 등)를 실행
BindingResult	유효성 검사 결과를 담는 객체. 오류 여부 및 메시지 확인 가능
model.addAttribute()	뷰에 전달할 데이터를 모델에 담음 (템플릿에서 사용 가능)
redirect:	뷰가 아니라 URL로 리다이렉트하라는 의미 (HTTP 302)

📡 LoginController.java

// Spring MVC 컨트롤러로 지정. HTTP 요청을 처리하고 뷰를 반환함
@Controller

// final 필드(userRepository)에 대해 생성자 자동 생성 (의존성 주입)
@RequiredArgsConstructor
public class LoginController {

    // User 엔티티에 접근할 수 있는 리포지토리 (DB와 연결됨)
    private final UserRepository userRepository;

    // 루트(/) 또는 /login 경로로 GET 요청이 들어오면 로그인 폼을 보여줌
    @GetMapping({"/", "login"}) // "/" 또는 "/login" 모두 이 메서드로 처리
    public String loginForm(Model model) {
        // login.html 템플릿에서 사용할 loginDto 객체를 모델에 담아 전달
        model.addAttribute("loginDto", new LoginDto());
        // 뷰 이름 반환 → templates/login.html 렌더링됨
        return "login";
    }

    // 로그인 폼에서 POST 요청이 들어올 때 실행
    @PostMapping("/login")
    public String login(
            // 클라이언트 form 데이터 바인딩 → LoginDto 객체에 매핑
            // @Valid: LoginDto에 정의된 유효성 검사(@NotBlank 등) 실행
            @Valid @ModelAttribute LoginDto loginDto,

            // 유효성 검사 결과 저장 (오류 발생 여부 확인 가능)
            BindingResult bindingResult,

            // 세션 객체: 로그인 상태를 저장하는 데 사용
            HttpSession httpSession,

            // 모델: 에러 메시지를 뷰로 전달하는 데 사용
            Model model
    ) {
        // 유효성 검사 실패 시 다시 로그인 페이지로 이동
        if (bindingResult.hasErrors()) return "login";

        // username으로 사용자 조회 (Optional → 없으면 null 반환)
        User user = userRepository.findByUsername(loginDto.getUsername()).orElse(null);

        // 아이디가 없거나 비밀번호가 일치하지 않을 경우
        if (user == null || !user.getPassword().equals(loginDto.getPassword())) {
            // 에러 메시지를 모델에 담고 로그인 페이지로 돌아감
            model.addAttribute("error", "아이디/비밀번호가 올바르지 않습니다");
            return "login";
        }

        // 로그인 성공 시, 사용자 정보를 세션에 저장
        // 이후 요청에서도 로그인 상태를 유지하기 위해 사용
        httpSession.setAttribute("user", user);

        // 게시글 목록 페이지로 리다이렉트
        return "redirect:/posts";
    }
}

개념	설명
@GetMapping({"/", "login"})	여러 URL을 하나의 메서드로 처리함
@ModelAttribute	클라이언트의 form 필드를 DTO에 바인딩함
@Valid	DTO에 설정된 유효성 검사를 자동 수행함
BindingResult	유효성 검사 결과를 확인할 수 있는 객체 (에러 있으면 처리)
HttpSession	서버가 클라이언트의 로그인 상태를 유지하기 위한 저장소
model.addAttribute()	뷰에 데이터를 전달함 (<span th:text="${error}">) 등으로 출력 가능
redirect:/posts	로그인 성공 후 게시글 목록 페이지로 리다이렉트 (HTTP 302)

📡 PostController.java

// 이 클래스가 Spring MVC 컨트롤러임을 나타냄
@Controller

// 요청 경로 "/posts"로 시작하는 모든 요청을 이 컨트롤러에서 처리
@RequestMapping("/posts")

// final 필드에 대해 생성자를 자동으로 생성하여 의존성 주입 (Lombok)
@RequiredArgsConstructor
public class PostController {

    // 게시글 데이터를 DB에서 조회/저장하는 데 사용하는 JPA 리포지토리
    private final PostRepository postRepository;

    // 댓글 관련 DB 작업을 위한 리포지토리 (향후 댓글 추가 시 사용)
    private final CommentRepository commentRepository;

    // 현재 로그인된 사용자를 세션에서 꺼내오는 헬퍼 메서드
    // 세션에 저장된 "user" 속성을 User 객체로 캐스팅해서 반환
    private User currentUser(HttpSession httpSession) {
        return (User) httpSession.getAttribute("user");
    }

    // 게시글 목록 페이지 요청 (GET /posts)
    @GetMapping
    public String list(Model model) {
        // 전체 게시글 리스트를 모델에 담아서 post-list.html로 전달
        model.addAttribute("posts", postRepository.findAll());
        return "post-list";
    }

    // 게시글 작성 폼 요청 (GET /posts/add)
    @GetMapping("/add")
    public String addForm(Model model, HttpSession httpSession) {
        // 로그인하지 않은 사용자는 로그인 페이지로 리다이렉트
        if (currentUser(httpSession) == null) return "redirect:/login";

        // 빈 PostDto를 모델에 담아 템플릿에서 form 바인딩에 사용
        model.addAttribute("postDto", new PostDto());

        // 게시글 작성 폼 페이지 렌더링 (post-form.html)
        return "post-form";
    }

    // 게시글 작성 폼 제출 처리 (POST /posts/add)
    @PostMapping("/add")
    public String add(
            // form 데이터가 postDto에 바인딩되고, 유효성 검사 수행
            @Valid @ModelAttribute PostDto postDto,

            // 유효성 검사 결과 저장. 오류 있으면 처리 가능
            BindingResult bindingResult,

            // 세션을 통해 로그인 사용자 정보를 가져오기 위함
            HttpSession httpSession
    ) {
        // 입력값 유효성 검사 실패 시, 다시 작성 폼 페이지로 이동
        if (bindingResult.hasErrors()) return "post-form";

        // 세션에서 로그인된 사용자 정보 가져옴
        User user = currentUser(httpSession);

        // 게시글 엔티티 생성: 제목, 내용, 작성자, 작성시간 설정
        Post post = Post.builder()
                .title(postDto.getTitle())
                .content(postDto.getContent())
                .author(user) // 현재 로그인 사용자
                .createdAt(LocalDateTime.now()) // 현재 시각
                .build();

        // 게시글 저장
        postRepository.save(post);

        // 게시글 목록 페이지로 리다이렉트
        return "redirect:/posts";
    }
}

요소	설명
@RequestMapping("/posts")	이 컨트롤러 내 모든 URL은 /posts로 시작
@GetMapping, @PostMapping	각각 GET/POST 요청을 처리
@Valid, BindingResult	DTO 유효성 검사 및 검증 결과 처리
HttpSession	로그인 정보를 서버 세션에 저장하고 가져오는 데 사용
currentUser()	세션에서 로그인된 사용자를 안전하게 가져오는 유틸 함수
model.addAttribute("postDto", new PostDto())	form 바인딩을 위한 객체 전달
LocalDateTime.now()	게시글 작성 시간을 현재 시간으로 지정

🖼️ signup.html

<h1>📜 회원가입</h1>

<!-- 서버에서 모델로 전달된 'error' 속성이 있을 때만 출력되는 오류 메시지 영역 -->
<!-- 예: 아이디 중복 시 "이미 사용중인 아이디입니다" 메시지 표시 -->
<div th:if="${error}" class="error" th:text="${error}"></div>

<!-- 회원가입 폼 -->
<!-- th:action → 폼 제출 경로를 지정 (/signup) -->
<!-- th:object → 이 폼이 바인딩될 객체 지정 (SignupDto) -->
<form th:action="@{/signup}"
      th:object="${signupDto}"
      method="post"
      class="form-container">

    <!-- 아이디 입력 필드 -->
    <!-- th:field="*{username}" → signupDto.username에 바인딩됨 -->
    <!-- 자동으로 name="username"과 value 바인딩됨 -->
    <label>
        아이디:
        <input type="text" th:field="*{username}"/>
    </label>

    <!-- username 필드에 유효성 검사 오류가 있을 경우 메시지를 출력 -->
    <!-- 예: "아이디는 필수입니다", "아이디는 4자 이상이어야 합니다" 등 -->
    <div th:if="${#fields.hasErrors('username')}" th:errors="*{username}"></div>

    <!-- 비밀번호 입력 필드 -->
    <!-- 마찬가지로 signupDto.password와 바인딩됨 -->
    <label>
        비밀번호:
        <input type="password" th:field="*{password}"/>
    </label>

    <!-- password 필드에 유효성 검사 오류가 있을 경우 메시지를 출력 -->
    <div th:if="${#fields.hasErrors('password')}" th:errors="*{password}"></div>

    <!-- 회원가입 제출 버튼 -->
    <button type="submit">가입하기</button>

    <!-- 로그인 페이지로 이동하는 링크 -->
    <a th:href="@{/login}" class="cancel">로그인</a>
</form>

🖼️ login.html

<body class="container">
<!-- 전체 페이지에 적용할 CSS 클래스 "container" (레이아웃 정렬용) -->

<h1>🔑 로그인</h1>
<!-- 로그인 페이지 제목 (🔑 이모지로 시각적 강조) -->

<!-- 서버에서 모델로 전달된 error 메시지가 있을 경우 출력 -->
<!-- 예: 로그인 실패 시 "아이디/비밀번호가 올바르지 않습니다" -->
<div th:if="${error}" class="error" th:text="${error}"></div>

<!-- 로그인 폼 -->
<form th:action="@{/login}"           <!-- 로그인 처리 경로 (POST /login) -->
      th:object="${loginDto}"         <!-- 이 폼이 loginDto 객체와 바인딩됨 -->
      method="post"                   <!-- HTTP POST 방식으로 전송 -->
      class="form-container">         <!-- CSS 클래스 (스타일링용) -->

    <!-- 아이디 입력 필드 -->
    <label>
        아이디:
        <!-- loginDto.username과 바인딩됨 -->
        <!-- 자동으로 name="username"과 value="..." 속성이 적용됨 -->
        <input type="text" th:field="*{username}"/>
    </label>

    <!-- username 필드에 유효성 검사 오류가 있는 경우 메시지 출력 -->
    <div th:if="${#fields.hasErrors('username')}" th:errors="*{username}"></div>

    <!-- 비밀번호 입력 필드 -->
    <label>
        비밀번호:
        <!-- loginDto.password와 바인딩됨 -->
        <input type="password" th:field="*{password}"/>
    </label>

    <!-- password 필드에 유효성 검사 오류가 있는 경우 메시지 출력 -->
    <div th:if="${#fields.hasErrors('password')}" th:errors="*{password}"></div>

    <!-- 로그인 버튼 -->
    <button type="submit">로그인</button>

    <!-- 회원가입 페이지로 이동하는 링크 -->
    <a th:href="@{/signup}" class="cancel">회원가입</a>
</form>
</body>

🖼️ post-list.html

<body>
<h1>📋 게시판</h1>
<p>
    <a th:href="@{/posts/add}">
        <button>➕ 새 글</button>
    </a>
    <a th:href="@{/logout}">
        <button class="cancel">로그아웃</button>
    </a>
</p>

<ul class="post-list">
    <li th:each="post: ${posts}">
        <div class="post">
            <h2>
                <a th:href="@{'/posts/' + ${post.id}}" th:text="${post.title}"></a>
            </h2>
            <p>
                작성자:
                <span th:text="${post.author.username}"></span>
                |
                <span th:text="${#temporals.format(post.createdAt, 'yyyy-MM-dd HH:mm')}"></span>
            </p>
        </div>
    </li>
</ul>
</body>

🖼️ post-form.html

<h1>새 게시글</h1>
<div th:if="${error}" class="error" th:text="${error}"></div>
<form th:action="@{/posts/add}"
      th:object="${postDto}"
      method="post"
      class="form-container">
    <p>
        <label>
            제목:
            <input type="text" th:field="*{title}" />
        </label>
    </p>
    <p>
        <label>
            내용:
            <textarea rows="6" th:field="*{content}"/></textarea>
        </label>
    </p>
    <button type="submit">저장</button>
    <a th:href="@{/posts}" class="cancel">취소</a>
</form>

🌿 Thymeleaf 문법 정리

📦 1. 변수 표현

문법	설명	예시
${...}	Model에 담긴 값을 참조	${error}, ${user.username}
*{...}	th:object 기준 객체의 필드 참조	*{username}, *{password}
@{...}	URL 링크 표현 (컨텍스트 경로 자동 포함)	@{/login}, @{/posts/{id}(id=1)}

---

🧩 2. Form 처리 (바인딩 & 유효성 검증)

문법	설명	예시
th:object	<form>과 바인딩할 객체 설정	<form th:object="${loginDto}">
th:field	name, id, value 자동 설정	<input th:field="*{username}"/>
th:errors	해당 필드의 유효성 검사 메시지 출력	<div th:errors="*{username}"/>
#fields.hasErrors('필드명')	필드에 오류가 있는지 검사	th:if="${#fields.hasErrors('password')}"

---

🔁 3. 조건문 & 반복문

문법	설명	예시
th:if	조건이 true일 경우 해당 요소 렌더링	<div th:if="${error}">에러</div>
th:each	리스트 등을 반복 출력	<tr th:each="post : ${posts}">...</tr>

✅ th:each 예시

<ul>
  <li th:each="user : ${users}" th:text="${user.username}"></li>
</ul>

---

🎨 4. 동적 속성 처리 (스타일 등)

문법	설명	예시
th:classappend	조건에 따라 클래스 추가	th:classappend="${post.pinned} ? 'highlight' : ''"
th:style	인라인 스타일 동적 설정	th:style="'color:' + ${color}"
th:attr	기타 HTML 속성 동적으로 설정	th:attr="data-id=${user.id}"

✅ th:classappend 예시

<div class="post" th:classappend="${post.pinned} ? 'pinned' : ''">
  게시글
</div>

---

🧪 5. 기타 유용한 표현식

문법	설명	예시
th:text	HTML Escape 후 텍스트 출력	<span th:text="${username}"></span>
th:utext	Escape 없이 HTML 태그까지 렌더링	<div th:utext="${content}"></div>
th:value	<input> 등에 값 명시적으로 설정	<input th:value="${user.email}"/>
th:href	링크 URL 설정	<a th:href="@{/signup}">회원가입</a>

---

🎯 핵심 정리 포인트

• ${} → 모델 데이터 접근
• *{} → 폼 객체(th:object) 내부 필드 접근
• @{} → URL 경로 표현
• #fields → 유효성 검사 도구
• th:each → 리스트 반복 출력
• th:classappend → 조건부 스타일 처리

✨ 사용 팁

• th:field를 사용하면 value, name, id를 자동으로 설정해주므로 폼 처리가 매우 간결해집니다.
• th:errors는 BindingResult와 함께 사용할 때만 출력됩니다.
• th:each, th:if는 JSP의 c:forEach, c:if를 대체합니다.