hi_do.log https://velog.io/ 하이도의 BackEnd 입문 Thu, 07 Nov 2024 05:00:16 GMT https://validator.w3.org/feed/docs/rss2.html https://github.com/jpmonette/feed hi_do.log https://velog.velcdn.com/images/hi_do/profile/fe5ef41e-9179-4776-b3f1-61d2b87fce9a/image.jpeg https://velog.io/ Copyright (C) 2019. hi_do.log. All rights reserved. <![CDATA[Spring IntellIJ (HTML에 서버데이터 넣기)]]> https://velog.io/@hi_do/Spring-IntellIJ-HTML%EC%97%90-%EC%84%9C%EB%B2%84%EB%8D%B0%EC%9D%B4%ED%84%B0-%EB%84%A3%EA%B8%B0 https://velog.io/@hi_do/Spring-IntellIJ-HTML%EC%97%90-%EC%84%9C%EB%B2%84%EB%8D%B0%EC%9D%B4%ED%84%B0-%EB%84%A3%EA%B8%B0 Thu, 07 Nov 2024 05:00:16 GMT 먼저 list.html을 수정할거다 이미지를 넣는 것을 먼저 한다

 <div class="card">
        <img src="https://placehold.co/300">
        <div>
        <h4 th:text="${name}">바지</h4>
        <p>7만</p>

이런식으로 를 사용한다

그리고 css를 만들어 줄거다 static에 main.css를 만들어준다

.card {
 margin : 30px auto;
 display : flex;
}
.card img {
 width : 150px;
 margin-right : 20px;
}

그리고 이 css를 html에서 사용하려면 아래에 </p> <pre><code> <title>Document</title> <link href="/main.css" rel="stylesheet"></code></pre><p> 이렇게 넣어주면 된다 </p> <pre><code class="language-html"><!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0"> <meta http-equiv="X-UA-Compatible" content="ie=edge"> <title>Document</title> <link href="/main.css" rel="stylesheet"> </head> <body> <div class="card"> <img src="https://placehold.co/300"> <div> <h4 th:text="${name}">바지</h4> <p>7만</p> </div> </div> <div class="card"> <img src="https://placehold.co/300"> <div> <h4 th:text="${name}">셔츠</h4> <p>7만</p> </div> </div> </body> </html></code></pre> <p> 이제 실행을 하여 'localhost:8080/list'에 들어가보면 <img src="https://velog.velcdn.com/images/hi_do/post/55713e06-76a0-4a39-9015-4385775b021a/image.png" alt=""> 이렇게 나온다</p> ]]></description> </item> <item> <title><![CDATA[Spring IntellIJ(DB데이터 출력)]]> https://velog.io/@hi_do/Spring-IntellIJDB%EB%8D%B0%EC%9D%B4%ED%84%B0-%EC%B6%9C%EB%A0%A5 https://velog.io/@hi_do/Spring-IntellIJDB%EB%8D%B0%EC%9D%B4%ED%84%B0-%EC%B6%9C%EB%A0%A5 Wed, 23 Oct 2024 07:12:54 GMT 라이브러리를 먼저 하나 설치하자 Lombok인데 필요한 코드를 자동으로 생성해줘서 자바 코드 양을 매우 줄여주는 간단한 라이브러리다.

dependencies {
  compileOnly 'org.projectlombok:lombok'
  annotationProcessor 'org.projectlombok:lombok'
}

Lombok(코드 자동생성 라이브러리) 하단에 이렇게 나오면 'Configure plugins'를 클릭하여 Lombok을 Install 해주자

  • 만약 나오지 않는 경우 'Setting -> Plugins'에서 Lombok을 검색하여 Install 한다 그리고 'Setting'에서 'annotation process'를 검색하여 'Enable annotation processing'을 체크해주자

JPA로 데이터 입출력하려면 3가지 단계가 있다

  1. repository만들기
  2. 원하는 클래스에 repository 등록
  3. repository.입출력문법()쓰기

1. repository만들기

ItemRepository.java

package com.apple.shop;

import org.springframework.data.jpa.repository.JpaRepository;

public interface ItemRepository  extends JpaRepository<Item, Long> {

}

2. 원하는 클래스에 repository 등록

ItemController.java

package com.apple.shop;

import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
@RequiredArgsConstructor
public class ItemController {

   private final ItemRepository itemRepository;

    @GetMapping("/list")
    String list(Model model){
        model.addAttribute("name","홍길동");
        return "list.html";
    }

}

3. repository.입출력문법()쓰기

ItemController.java

package com.apple.shop;

import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

import java.util.ArrayList;

@Controller
@RequiredArgsConstructor
public class ItemController {

   private final ItemRepository itemRepository;

    @GetMapping("/list")
    String list(Model model){
        var result = itemRepository.findAll();
        System.out.println(result);

        var a = new ArrayList<>();
        a.add(30);
        a.add(40);
        System.out.println(a);

        model.addAttribute("name","홍길동");
        return "list.html";
    }

}

(.findAll은 테이블의 모든 데이터를 가져온다) 출력을 해보면 이렇게 나온다 (이게 ArrayList의 생김새다)

  • ArrayList에서 하나만 출력하려면

    var a = new ArrayList<>();
      a.add(30);
      a.add(40);
      System.out.println(a);

    에서 

    System.out.println(a);

    이 부분을 

    System.out.println(a.get(몇번째 자료를 출력할것인지 입력));

    이렇게 변경해준다

  • 위의 코드를 

    ArrayList<ArrayList에 보관할 자료 타입> a = new ArrayList<>();

    이렇게도 변경 가능하다

  • (참고) Lombok 없이 등록하는 법

    package com.apple.shop;

import lombok.RequiredArgsConstructor; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Controller; import org.springframework.ui.Model; import org.springframework.web.bind.annotation.GetMapping;

@Controller public class ItemController {

private final ItemRepository itemRepository; @Autowired public ItemController(ItemRepository itemRepository) { this.itemRepository = itemRepository; }

@GetMapping("/list")
String list(Model model){

    model.addAttribute("name","홍길동");
    return "list.html";
}

} ```

]]> <![CDATA[Spring IntellIJ (테이블 만들기 Entity)]]> https://velog.io/@hi_do/Spring-IntellIJ-%ED%85%8C%EC%9D%B4%EB%B8%94-%EB%A7%8C%EB%93%A4%EA%B8%B0-Entity https://velog.io/@hi_do/Spring-IntellIJ-%ED%85%8C%EC%9D%B4%EB%B8%94-%EB%A7%8C%EB%93%A4%EA%B8%B0-Entity Mon, 21 Oct 2024 06:40:49 GMT 테이블을 만들고 싶다면 JPA에서는 @Entity클래스를 만들면 자동생성된다. 테이블을 만들때는 테이블에 어떤 컬럼이 들어갈지도 먼저 정해야한다.

Item.java

package com.apple.shop;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;

@Entity
public class Item {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    Long id;
    String title;
    Integer price;
}

컬럼용 변수에는 int 말고 Integer를 강요한다 (int/Integer는 20억까지 저장가능하다.) id 컬럼에는 @Id를 사용해야한다. @GeneratedValue를 사용하면 id를 알아서 1씩 증가 시켜준다.(정확히는 @GeneratedValue(strategy = GenerationType.IDENTITY) 이다)

  • SQL을 잘 아는 것처럼 보이려면 @Id는 primary key로 설정해주는 역할이고 @GeneratedValue는 auto increment 기능이라고 말한다.

이제 실행을 해주고 잘 됬는지 확인하기 위해 DBeaver에서 확인한다. 짠! 모두 잘 나왔다! 이제 상품 몇개를 넣어보자 아래의 row추가 버튼을 클릭한다 이제 하나하나 입력해주면 된다. 근데 이게 귀찮다고한다면 상단의 SQL을 누른 후 이렇게 입력해주고 실행버튼 누르면 된다. (실행버튼은 저 주문서 같은 아이콘) 짠! 3개 모두 추가되었다!

한가지 추가할게 생겼다. 아까 Entity코드 안의 변수에 public을 붙여준다.

Item.java

package com.apple.shop;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;

@Entity
public class Item {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    public Long id;
    public String title;
    public Integer price;
}

이유는 public이 없으면 같은 폴더내의 클래스에서만 사용가능하기 때문에 다른 모든 클래스에서 문제없이 사용 가능하려면 public을 붙여준다.

이제 @Column()으로 컬럼에 제약설정을 해보자

    public String title;

저기 'nullable = false'라는 것은 '이 컬럼이 비어있으면 테이블에 입력을 막아달라' 라는 의미다. 'unique = true'은 '이 컬럼값이 유니크하지 않으면 테이블 입력을 막아달라' 라는 의미다. 추가로 'columnDefinition = "TEXT"'는 컬럼타입을 강제로 지정이 가능하다. 이처럼 @Column 에너테이션을 사용하면 이렇게 제약설정을 할 수 있다.

  • 참고사항: 컬럼설정 변경사항은 DB에 반영이 자동으로 안될 수도 있다.
]]> <![CDATA[Spring IntellIJ (Database 연결 및 JPA 설치)]]> https://velog.io/@hi_do/Spring-IntellIJ-Database-%EC%97%B0%EA%B2%B0-%EB%B0%8F-JPA-%EC%84%A4%EC%B9%98 https://velog.io/@hi_do/Spring-IntellIJ-Database-%EC%97%B0%EA%B2%B0-%EB%B0%8F-JPA-%EC%84%A4%EC%B9%98 Mon, 21 Oct 2024 06:01:09 GMT 데이터베이스를 만드려면 'Consoles->Connection'으로 들어가서 sql코드를 작성하면 된다. 대충 이렇게 작성하고 재생을 누르면 이렇게 창이 나오는데 파란 버튼을 눌러주자 'Reload'버튼을 누르면 'shop'이 생성되었다 그리고 이번에는 라이브러리를 추가할거다.

dependencies {
  runtimeOnly 'com.mysql:mysql-connector-j'
  implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
}

이것은 JPA와 MySQL 접속도와주는 라이브러리다. 'org.springframework.boot:spring-boot-starter-data-jpa'는 ORM라이브러리인데 이것을 사용하면 Java코드로 데이터 입출력이 가능해지고, 뽑은 데이터 타입체크도 편하고, 데이터를 Java 스타일로 관리가 가능하다. 단점은 데이터 입출력 속도가 저하된다는 거다.

이제 'application.properties'에

spring.datasource.url=jdbc:mysql://호스팅받은곳엔드포인트주소/만든database이름
spring.datasource.username=DB접속아이디
spring.datasource.password=DB접속비번
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.jpa.properties.hibernate.show_sql=true
spring.jpa.hibernate.ddl-auto=update

이 코드를 입력해준다. 'application.properties'라는 파일이 무엇이냐면 설정과 환경변수를 보관하는 파일이다. 그리고 이 코드가 위에 받았던 라이브러리가 필요로하는 설정들이다. 이런식으로 입력해주면 된다.

위의 코드에서'spring.jpa.properties.hibernate.show_sql=true' 이 부분은 JPA 문법을 쓸 때 SQL 따로 출력해줄지의 여부 의미한다.

그리고'spring.jpa.hibernate.ddl-auto=update' 이 부분은 테이블 생성을 자동으로 할지의 여부를 의미한다.

]]> <![CDATA[Spring IntellIJ (MySQL)]]> https://velog.io/@hi_do/Spring-IntellIJ-MySQL https://velog.io/@hi_do/Spring-IntellIJ-MySQL Wed, 16 Oct 2024 16:30:23 GMT portal.azure.com에서 클라우드를 사용하여 MySQL을 호스팅 받을거다. 실제 서비스를 운영할거라는 가정하에 클라우드 서비스에서 호스팅을 받는게 안정적이라고 생각이 들어서 이것을 선택했다. MySQL을 검색하면 저렇게 나오는데 '유동 서버'를 클릭하자 일단 무료로 사용해야하니까 최소한으로 하기 위해 다음과 같이 설정하자

이렇게하여 만들면 몇분 뒤에 만들어져서 이렇게 나온다 그리고 들어가서 '서버 매개 변수'에서 'require'을 검색하여 'require_secure_transport'의 값을 'OFF'로 변경해준다 *이 사이트에서 DB를 확인하지 못한다..! 따라서 IntellIJ에서 plugin을 받아줘야한다. 'Setting' -> 'Plugins' 에서 'database'를 검색하고 이녀석을 받아준다. 이것을 누르면 MySQL DB에 connect를 할 수 있다! 여기서 'host'에 여기의 서버 이름을 복사해서 붙여넣으면 된다. 그리고 사용할 아이디와 비밀번호(아까 만든거!)를 입력후 'Test Connection'을 클릭해보면 성공했다고 나온다 이제 'OK' 버튼을 누르면 짠! DB완료! 근데 이렇게 보면 버그가 많이 나와서 DB보려면 DBeaver를 추천한다고 한다 DBeaver을 실행시켜서 데이터베이스->새 데이터베이스연결 을 클릭한다. 여기서 MySQL을 선택해주고 다음으로 넘어가서 'Server Host'에는 아까의 주소를 적고 Username과 Password에는 아까 만든 아이디와 비밀번호를 적는다. 이제 Test를 돌렸더니

...?!?! 문제점 발생..... 확인해본 결과 이녀석을 "OFF"로 바꿔줘야 한다. 다시 Test를 돌려보면 성공!!!

이렇게 연결되면 성공이다

]]> <![CDATA[Spring IntellIJ (Thymeleaf)]]> https://velog.io/@hi_do/Spring-IntellIJ-Thymeleaf https://velog.io/@hi_do/Spring-IntellIJ-Thymeleaf Wed, 16 Oct 2024 09:18:40 GMT 먼저 Controller 파일을 하나 만들어준다. 첫번째 줄에 package라는 것은 꼭 있어야한다! 저 package라는 것이 없으면 import 사용이 불가능하기 때문!! 그리고 저기 class 앞에 public이 없으면 같은 폴더(패키지) 안에서만 사용가능하다!

'상품페이지'를 만들기 위해 static에 list.html파일을 만들어 준다.

list.html

<!doctype html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport"
          content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>
<body>
    <div>
        <img>
        <h4>바지</h4>
        <p>7만</p>
    </div>
<div>
    <img>
    <h4>셔츠</h4>
    <p>8만</p>
</div>

</body>
</html>

이제 'ItemController'를 마저 작성해보자
> ItemController.java
```java
package com.apple.shop;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
@Controller
public class ItemController {
    @GetMapping("/list")
    String list(){
        return "list.html";
    }
}

이렇게하면 결과가 잘 나온다!

이제 템플릿엔진 중 'Thymeleaf'를 사용해보자!

build.gradle

dependencies {
   implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
}

여기서 이것을 클릭하면 라이브러리가 다운된다. (완료됬으면 서버 껐다가 다시 실행해야한다.)

html에 서버데이터를 넣으려면 우선 templates 폴더에 .html 파일을 넣어둬야한다.

html에 서버 데이터를 넣으려면

  1. 파라미터에 Model model을 넣고
    package com.apple.shop;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
@Controller
public class ItemController {
 @GetMapping("/list")
 String list(Model model){
     return "list.html";
 }
}
  2. model.addAttribute(작명,데이터)를 넣고 
    package com.apple.shop;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
@Controller
public class ItemController {
 @GetMapping("/list")
 String list(Model model){
     model.addAttribute("name","홍길동");
     return "list.html";
 }
}
  3. html 파일에서는 th:text="${작명}" list.html
    <!doctype html>
<html lang="en">
<head>
 <meta charset="UTF-8">
 <meta name="viewport"
       content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
 <meta http-equiv="X-UA-Compatible" content="ie=edge">
 <title>Document</title>
</head>
<body>
 <div>
     <img>
     <h4 th:text="${name}">바지</h4>
     <p>7만</p>
 </div>
<div>
 <img>
 <h4>셔츠</h4>
 <p>8만</p>
</div>
</body>
</html>
    ('th:text="${작명}"'은 Thymeleaf문법이다)

결과가 이렇게 나온다.

]]> <![CDATA[Spring IntelliJ (Controller)]]> https://velog.io/@hi_do/Spring-IntelliJ-Controller https://velog.io/@hi_do/Spring-IntelliJ-Controller Wed, 16 Oct 2024 08:42:02 GMT

IntelliJ 에서 html을 작성할때 팁! '!'를 입력후 'tab'을 누르면 자동으로 완성된다 짠!

다음으로 컨트롤러에 관한 예시이다. @Controller는 Spring문법이다. @Controller는 서버기능을 만들고 싶을때 Class위에 작성한다. @GetMapping은 'localhost:8080'+()의 사이트로 이동하면 그 페이지에 대해 작성한 것들이 나온다. 그리고 @GetMapping 아래로 두가지 예시인데 @ResponseBody를 쓴것과 안쓴것이 있는데 @ResponseBody는 return을 문자 그대로 보여주기 때문에 html을 return할때는 사용하지 않는다.

]]> <![CDATA[Spring(초기 세팅)]]> https://velog.io/@hi_do/%ED%98%BC%EC%9E%90%EC%84%9C-%ED%95%B4%EB%B3%B4%EB%8A%94-Spring https://velog.io/@hi_do/%ED%98%BC%EC%9E%90%EC%84%9C-%ED%95%B4%EB%B3%B4%EB%8A%94-Spring Mon, 14 Oct 2024 14:42:38 GMT 왠만하면 버전은 괄호가 없는것으로 하자(괄호 없는게 제일 안전하다고 한다) 이제 압축파일 받아서 풀자 Spring Initiallizr에서 만들어서 하는 이유는 Intellij가 무료 버전이라 여기 자체에서 만드는게 유료이기 때문이다 '열기'를 클릭하자 여기 있다! 처음에 몇가지 세팅해야 할게 있다. 먼저 File -> Project Structure에서 java를 확인해야함 이렇게 설정해놓은 버전보다 높은 버전을 설정해야 한다 나는 처음에 17로 해놔서 sdk는 22로 했다 다음으로 gradle! File -> Setting 으로 들어가서 gradle을 입력하여 확인한다. 여기서 이렇게 IntelliJ IDEA로 변경해준다. 또한 이렇게 변경하면 한가지를 더 변경해야한다. 똑같이 Setting에서 java compiler를 입력하여 들어가서 Additional command line parameters에 '-parameters'를 입력해준다 그리고 Plugins에서 'one dark native'를 받아준다. 이제 기본적으로 있던 public class~~ 를 실행해보자 이러면 일단 실행이 된거다 port 번호가 8080이기 때문에 'localhost:8080'으로 들어가보면 저런 화면이 나온다 이러면 서버가 실행된거다

]]> <![CDATA[Eclipse에서 sts 실행]]> https://velog.io/@hi_do/Eclipse%EC%97%90%EC%84%9C-sts-%EC%8B%A4%ED%96%89 https://velog.io/@hi_do/Eclipse%EC%97%90%EC%84%9C-sts-%EC%8B%A4%ED%96%89 Tue, 08 Oct 2024 07:55:43 GMT Help에서 Eclipse Marketplace로 들어간다 Find에서 Spring을 검색하여 Spring Tool 4를 Install 해준다. 다 받아지면 restart를 눌러 다시 시작해준다. 이제 재실행된 Eclipse에서 File -> New -> Other로 들어가서 들어가보면 아까 없던 Spring Boot가 생겼다! 이제 설정해서 실행하면 된다! Next를 눌러서 다음 화면으로 오는데 일단 저렇게만 선택해서 하자 Finish를 클릭하면 끝! Run As -> Spring Boot App을 눌러 실행해보자! 성공적으로 작동한다! 이제 'http://localhost:8080/'을 주소에 입력하여 제대로 작동하는지 확인해보자 이제 기본 페이지를 만들어보자 resources -> static -> index.html을 만들어보자 이제 종료하고 다시 실행해보면 이렇게 나오는걸 확인할 수 있다.

]]> <![CDATA[WSL 설치]]> https://velog.io/@hi_do/WSL-%EC%84%A4%EC%B9%98 https://velog.io/@hi_do/WSL-%EC%84%A4%EC%B9%98 Wed, 25 Sep 2024 15:39:02 GMT WSL설치

찾기에서 'Windows PowerShell'을 찾아서 실행한다. 여기서 'wsl --install'을 입력하면 wsl이 설치된다. 이제 여기서 이녀석을 찾아 설치하여 실행한다. 와중에 갑자기 오류가 발생했다... 3트째 오류 발생이라 답답했다.... 무엇이 문제인가 해서 알아보니 해결방법은 다음과 같았다. 제어판 -> 프로그램 -> Windows 기능 켜기/끄기 로 들어가서 이렇게 체크를 해야했다... 진작에 알아볼걸... 해결되었다!

Ubuntu 제거

아니 근데 다른 용무가 생겨서 꽤나 자리를 비운고 username을 입력하니 안되길래 그냥 삭제하고 다시 설치하려고한다. PowerShell을 실행하고 'wsl --list --all'을 입력해준다 'wsl --unregister '을 입력한다.

Ubuntu 재실행

이제 다시 실행하면 자 이제 차례대로 입력해보자 입력하면 이렇게 성공창이 나오고 오예! 완전 성공이야! 이제 wsl을 실행해보자 전에는 실행마저 안되더니 이제는 실행되면서 저렇게 나온다!

버전 확인

Powershell에서 'wsl -l -v'를 입력하여 버전을 확인한다.

]]> <![CDATA[Apache Tomcat 설치 및 설정]]> https://velog.io/@hi_do/Apache-Tomcat-%EC%84%A4%EC%B9%98-%EB%B0%8F-%EC%84%A4%EC%A0%95 https://velog.io/@hi_do/Apache-Tomcat-%EC%84%A4%EC%B9%98-%EB%B0%8F-%EC%84%A4%EC%A0%95 Tue, 24 Sep 2024 05:02:20 GMT Apache Tomcat 이란?

자바 서블릿(Java Servlet)이나 자바 서버 페이지(Java Server Page, JSP)로 동적 웹 사이트(dynamic websites)를 구축하려면 웹 어플리케이션 서버(Web Application Server, WAS)가 필요하다. WAS는 웹 서버(web server)가 전달해준 사용자의 요청을 받아서, 데이터베이스 서버와 통신하고 데이터를 가공하여 응답을 돌려주는 미들웨어 프로그램임

버전 차이점

아파치 톰캣은 여러 버전이 있는데 서블릿 코드를 작성하거나 자바 8 버전 이상을 사용 또는 자바 엔터프라이즈 에디션(Java Enterprise Edition, JavaEE)를 구현한 버전을 설치하려면 톰캣 9 버전을 사용하고 자카르타 엔터프라이즈 에디션(Jakarta Enterprise Edition, JakartaEE)를 구현한 버전을 사용하려면 톰캣 10을 사용한다고 한다. 따라서!! 나는 9버전을 다운받을 예정!!

Apache Tomcat 설치

https://tomcat.apache.org/whichversion.html 여기 사이트로 들어가면 된다. 들어가면 이런 페이지가 나온다. 여기서 'Tomcat 9'를 클릭하면 이 페이지로 넘어가는데 여기서 나는 '64-bit Windows zip' 이거를 받을거다. 설치가 완료되면 'C:\Program Files\Java' 이 경로로 압축을 풀어준다. 짠! 이런식으로 하면 일단 설치는 완료!

]]> <![CDATA[Eclipse Error - Launch configuration references non-existing project 해결 방법]]> https://velog.io/@hi_do/Eclipse-Error-Launch-configuration-references-non-existing-project-%ED%95%B4%EA%B2%B0-%EB%B0%A9%EB%B2%95 https://velog.io/@hi_do/Eclipse-Error-Launch-configuration-references-non-existing-project-%ED%95%B4%EA%B2%B0-%EB%B0%A9%EB%B2%95 Mon, 23 Sep 2024 16:02:27 GMT 실행을 하다가 갑자기 이런 창이 나왔다. 도대체 무엇인가 하면서 계속해도 이런 오류창이 계속 나와서 검색을 해봤다. 실행하고자 하는 곳에 오른쪽 마우스키를 이용하여 'Run As'의 'Run Configuration'을 클릭한다. 이런 창이 나오는데 여기서 'Java Application' 하위에 있는것을 모두 삭제하면 된다고 한다. 이렇게 하면 됨 그럼 해결!!

]]> <![CDATA[Java 환경변수 및 Eclipse 초기 설정]]> https://velog.io/@hi_do/Temp-Title-4l33n8kr https://velog.io/@hi_do/Temp-Title-4l33n8kr Mon, 23 Sep 2024 15:56:27 GMT Java 환경변수 설정

먼저 https://www.oracle.com/kr/java/technologies/downloads/ 에서 jdk를 설치한다. 나는 jdk23을 설치했다. 저 세개 중 이것을 설치하면 된다. 설치가 완료되면 로컬 디스크 c에 Java 폴더가 생겨있다. 이제 설치가 완료됬으니 환경변수를 설정해보자 여기 시스템 환경 변수 편집으로 이동한다. 여기서 환경변수(N)을 클릭한다. 시스템 변수의 새로만들기를 클릭한다. 변수 이름은 'JAVA_HOME'이라고 칭하겠다. 변수 값은 java를 설치했던 경로인 여기가 변수 값이다. 이제 확인을 클릭하면 이렇게 생겨진다. 다음으로 시스템 변수에서 새로만들기를 클릭하여 이렇게 생성한다. 다음으로 시스템 변수의 Path를 더블클릭하여 환경변수편집에서 새로만들기를 클릭한 후 이렇게 생성해 준다 그 후 위로 이동을 클릭하여 제일 위로 올려준다. 이제 제대로 됬는지 확인하기 위해 cmd를 실행한다. cmd 실행 후 'java -version'을 입력하여 확인한다. cmd에서 'javac'라고 입력하면 더 자세하게 나오긴한다.(참고)

Eclipse 설치

https://www.eclipse.org/downloads/ 이 사이트에서 설치하면 된다. 여기서 'Download Packages'를 클릭한다. 여기서 원하는 것을 설치하면 되는데 나는 windows라서 windows꺼를 설치한다. 설치가 완료되면 로컬디스크c에 압축을 풀어준다. (굳이 이러는 이유는 경로가 길면 압축해제가 안되기 때문이라나 뭐라나;;) 압축이 풀리면 Eclipse를 실행한다. 여기 이 창에서 상단의 돋보기 옆의 이 아이콘을 클릭한다. 그럼 이런 창이 나오는데 여기서 'Java'를 클릭한 후 'Open'을 클릭한다. 그다음 'Window'탭의 'Preferences'를 클릭한다. 그럼 이런 창이 나오는데 여기서 처음에 'Java'를 찾아서 'Insalled JRES'를 클릭한다. 그 다음 'Add'를 클릭하면 이런 창이 나오고 여기서 'Standard VM'을 클릭하고 'Next'를 클릭한다. 그럼 이런 창이 나오는데 여기서 'Directory'를 클릭하여 경로를 이동한다. 그럼 폴더 선택창이 나오는데 여기까지 이동하여 '폴더 선택' 클릭! ...................??!?!?!? (아... 이미 있다고 한다...안녕...) (그냥 원래 있는거 사용하면 될거 같다...) 짠! 완성!!!

]]> <![CDATA[AWS]]> https://velog.io/@hi_do/AWS https://velog.io/@hi_do/AWS Tue, 25 Jun 2024 02:46:41 GMT 초기 설정

초기에 지역 설정은 서울로 해야한다.(아니면 과금이 나갈 수도 있음) EC2 검색 후 클릭 추가 클릭 후 초기 화면 변경 해준다. ![] (https://velog.velcdn.com/images/hi_do/post/5bcc563d-8eb4-4d73-a278-8f5cc29d7acc/image.png) 인스턴스 시작 클릭 인스턴스 아이디 클릭 연결 클릭 원격 데스크톱 파일 다운로드 클릭 다운로드 완료 그후 암호 가져오기 클릭 프라이빗 파일 업로드 클릭 업로드하기 암호 해독 클릭 실행 암호 입력 하면 실행 됨 일단 실행되면 종료하기 인스턴스 클릭 완전히 종료해야 한다(돈나간다...)

bucket

버킷만들기 클릭 이 화면에 파일을 끌어다 놓으면 이런화면이 나온다 그 후 업로드 클릭 후 닫기 클릭 편집 클릭 활성화 클릭 후 index.html 입력 후 변경사항 저장 클릭

  • https://docs.aws.amazon.com/ko_kr/AmazonS3/latest/userguide/HostingWebsiteOnS3Setup.html (aws 사용법) 편집 클릭 방금 전 코드 복사해서 붙여넣기 버킷 ARN 복사하여 코드 변경 저장 버튼 누르기 객체 소유권 편집 ACL 활성화됨 클릭(다른 사람도 접근 가능하게 하기위해) 체크 후 저장 ACL 편집하기 모든사람 (읽기)클릭 후 저장 후 버킷으로 복귀 여기서 객체URL 클릭 클릭 하면 해당 링크로 이동됨

    bucket 삭제

    체크 후 삭제 클릭 버킷 비우기 클릭 영구 삭제 입력 후 비어있음 클릭 체크 후 삭제 클릭 버킷 이름 입력 후 버킷 삭제 클릭 -> 완료

인바운드와 아웃바운드

인스턴스 시작 클릭 기본 설정은 느려서 속도를 더 내기위해 AMI변경 원래 사용하던 키 사용 보안그룹 클릭 인바운드 규칙 편집 클릭 인바운드 추가하여 설정 인바운드 추가하여 설정 후 규칙 저장 아웃바운드 규칙 편집 클릭 아웃바운드 추가하여 설정 후 규칙 저장 그 후 인스턴스 들어가보면 실행중

실행방법

https://www.putty.org 두 파일 다운로드 yum list java17\ 입력해서 -> jdk17 설치 sudo yum install java-17-amazon-corretto.x86_64 입력하여 설치 그 후 y d입력하면 설치됨

####

버전이 나옴 generate 클릭하여 생성된 압축파일 여기에 압출 풀기 IntelliJ실행

####

index.html과 SampleController.java 생성

  • SampleController.java
    package com.appEC2.controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/api/sample")
public class SampleController {
  @GetMapping("/getArr")
  public String[] getArr(){
      return new String[]{"AAA","BBB","CCC"};
  }
}
  • 실행 결과
  • 깃허브로 프로젝트를 올리고 ec2에서 이 깃을 이용해서 내려받은 후에 빌드해서 실행하는 방법. 오류가 나와서 -> 이걸 다운 받아서 이용 위에 방법과 동일하다
  • private을 public으로 바꾸는 방법 sudo yum install git 입력 -> git 설치 mkdir webtest 입력 cd webtest 입력 pwd 입력 클론생성 git clone https://github.com/*/* 본인 깃헙 주소 입력 ls -> cd appEC2 -> ls -> ls -> sudo chmod 777 ./gradlew -> ./gradlew build 순서대로 입력 ls -> cd build -> ls 입력 java -jar ec2-0.0.1-SNAPSHOT.jar
]]> <![CDATA[SpringBoot - 로그인과 회원가입]]> https://velog.io/@hi_do/SpringBoot-%ED%9A%8C%EC%9B%90%EA%B0%80%EC%9E%85 https://velog.io/@hi_do/SpringBoot-%ED%9A%8C%EC%9B%90%EA%B0%80%EC%9E%85 Tue, 18 Jun 2024 06:38:22 GMT 스프링 시큐리티
  • 스프링 기반 웹 애플리케이션의 인증과 권한을 담당하는 스프링의 하위 프레임워크이다
  • 인증(authenticate)은 로그인과 같은 사용자의 신원을 확인하는 프로세스를, 권한(authorize)은 인증된 사용자가 어떤 일을 할 수 있는지(어떤 접근 권한이 있는지)를 관리하는 것을 의미한다.
  • build.gradle에 
    implementation 'org.springframework.boot:spring-boot-starter-security'
implementation 'org.thymeleaf.extras:thymeleaf-extras-springsecurity6'
    시큐리티와 타임리프를 연결해주는 라이브러리 추가 후 refresh

  • 적용후 실행 결과

  • 스프링 시큐리티는 기본적으로 인증되지 않은 사용자가 웹서비스를 사용할 수 없게끔 만드는게 기본값이다.
  • 로그인을 하지 않아도 게시물을 조회할 수 있도록 설정을 변경해줘야 한다.
  • SecurityConfig.java 생성
    package com.mysite.sbb;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.util.matcher.AntPathRequestMatcher;
@Configuration
@EnableWebSecurity    // 스프링 시큐리티 필터가 스프링 필터체인에 등록이 된다.
public class SecurityConfig {
  @Bean
  SecurityFilterChain filterChain(HttpSecurity http) throws Exception{
      http.authorizeHttpRequests((AuthorizeHttpRequests) ->
      AuthorizeHttpRequests.requestMatchers(new AntPathRequestMatcher("/**")).permitAll());
      return http.build();
  }
}
    @Configuration : 스프링의 환경 설정 파일 @EnableWebSECURITY : 모든 요청 URL이 스프링 시큐리티의 제어를 받도록 만드는 에너테이션

  • 이 에너테이션을 통해 시큐리티를 활성화시킬 수 있는데 내부적으로 SecurityFilterChain 클래스 동작하여 모든 요청 URL에 이 클래스 필터로 적용되어 URL별로 특별한 설정을 할 수 있다.

  • There was an unexpected error (type=Forbidden, status=403). Forbidden

  • 스프링 시큐리티의 CSRF방어 기능에 의해 H2콘솔 접근이 거부된것. CSRF는 웹 보안 공격 중 하나로, 조작된 정보로 웹 사이트가 실행되도록 속이는 공격 기술이다. 스프링 시큐리티는 이 공격을 방지하기 위해 CSRF 토큰을 세션을 통해 발행하고, 웹 페이지에서는 폼 전송시 해당 토큰을 함께 전송해서 실제 웹 페이지에서 작성한 데이터가 전달되는지를 검증한다. == 토큰이란 요청을 식별하고 검증하는데 사용하는 특수한 문자열 또는 값을 의미한다. == 세션이란 사용자의 상태를 유지하고 관리하는데 사용하는 기능이다.

<form action="/question/create" method="post"><input type="hidden" name="_csrf" value="SzbJ15G-MjZdJl7BGAw995aTGZxZJhiGCPmKbRKOXCOA2O8BegD_7qiHBgZwETulLCEJwK-iNP06Qi2raZjsXXbqaBq46dk1"/>

-> 스프링 시큐리티에 의해 CSRF토큰이 자동으로 생성된다. == CSRF토큰은 서버에서 생성되는 임의의값으로 페이지 요청시 항상 다른 값으로 생성한다. 스프링 시큐리티는 이런 식으로 페이지에 CSRF 토큰을 발행하여 이 값이 다시 서버로 정확하게 들어오는지 확인하는 과정을 거친다. 만약 CSRF 토큰이 없거나 해커가 임의의 CSRF 토큰을 강제로 만들어 전송하면 스프링 시큐리티에 의해 차단된다.

  • SecurityConfig.java 수정
    package com.mysite.sbb;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.util.matcher.AntPathRequestMatcher;
@Configuration
@EnableWebSecurity   // 스프링 시큐리티 필터가 스프링 필터체인에 등록이 된다.
public class SecurityConfig {
 @Bean
 SecurityFilterChain filterChain(HttpSecurity http) throws Exception{
    http.authorizeHttpRequests((authorizeHttpRequests) ->
    authorizeHttpRequests.requestMatchers(new AntPathRequestMatcher("/**")).permitAll())
    .csrf(csrf -> csrf    //    /h2-console/로 시작하는 모든 URL은 CSRF 검증을 하지 않겠다.
          .ignoringRequestMatchers(new AntPathRequestMatcher("/h2-console/**")));    
    return http.build();
 }
}

  • H2화면이 프레임 구조로 작성되어있다.
  • H2레이아웃이 화면처럼 작업 영역이 나눠져 있다.
  • 스프링 시큐리티는 웹 사이트의 콘텐츠가 다른 사이트에 포함되지 않도록 하기 위해 X-Frame-Options 헤더의 기본값을 DENY로 사용하는데, 프레임 구조의 웹사이트는 이 헤더의 값을 DENY인 경우 오류가 발생한다. == 스프링 부트에서 X-Frame-Options 헤더는 클릭재킹 공격을 막기 위해 사용한다. 클릭재킹 : 사용자의 의도와 다른 작업없이 수행되도록 속이는 보안 공격 기술
  • SecurityConfig.java 수정
    package com.mysite.sbb;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.header.writers.frameoptions.XFrameOptionsHeaderWriter;
import org.springframework.security.web.util.matcher.AntPathRequestMatcher;
@Configuration
@EnableWebSecurity   // 스프링 시큐리티 필터가 스프링 필터체인에 등록이 된다.
public class SecurityConfig {
 @Bean
 SecurityFilterChain filterChain(HttpSecurity http) throws Exception{
    http.authorizeHttpRequests((authorizeHttpRequests) ->
    authorizeHttpRequests.requestMatchers(new AntPathRequestMatcher("/**")).permitAll())
    .csrf(csrf -> csrf    //    /h2-console/로 시작하는 모든 URL은 CSRF 검증을 하지 않겠다.
          .ignoringRequestMatchers(new AntPathRequestMatcher("/h2-console/**")))
    .headers(headers -> headers
            .addHeaderWriter(new XFrameOptionsHeaderWriter(
                    XFrameOptionsHeaderWriter.XFrameOptionsMode.SAMEORIGIN)));      
    return http.build();
 }
}
  • URL 요청시 X-Frame-Options 헤더를 DENY 대신 SAMEORIGIN 으로 설정하여 오류가 발생하지 않도록 정의
  • X-Frame-Options 헤더의 값으로 SAMEORIGIN을 설정하면 프레임에 포함된 웹 페이지가 동일한 사이트에서 제공할때만 사용이 허락된다.

회원가입 기능 구현

  • 회원 entity username, password, email
  • SiteUser.java 생성
    package com.mysite.sbb.user;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@Entity
public class SiteUser {    
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;    
  @Column(unique = true)
  private String username;    
  private String password;    
  @Column(unique = true)
  private String email;
}
  • UserRepository.java(interface) 생성
    package com.mysite.sbb.user;
import org.springframework.data.jpa.repository.JpaRepository;
public interface UserRepository extends JpaRepository<SiteUser, Long>{
}
  • UserService.java 생성
    package com.mysite.sbb.user;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;
import lombok.RequiredArgsConstructor;
@RequiredArgsConstructor
@Service
public class UserService {
  private final UserRepository userRepository;
  public SiteUser create(String username, String email, String password) {
      SiteUser user = new SiteUser();
      user.setUsername(username);
      user.setEmail(email);
      // 스프링 시큐리티에서 BCrytPasswordEncoder를 사용
      // 해시함수를 사용하는데 비밀번호 같은 보안 정보를 안전하게 저장하고 검증할 때 사용하는 암호화 기술
      BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
      user.setPassword(passwordEncoder.encode(password));
      this.userRepository.save(user);
      return user;
  }
}
  • SecurityConfig.java
    package com.mysite.sbb;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.header.writers.frameoptions.XFrameOptionsHeaderWriter;
import org.springframework.security.web.util.matcher.AntPathRequestMatcher;
@Configuration
@EnableWebSecurity   // 스프링 시큐리티 필터가 스프링 필터체인에 등록이 된다.
public class SecurityConfig {
 @Bean
 SecurityFilterChain filterChain(HttpSecurity http) throws Exception{
    http.authorizeHttpRequests((authorizeHttpRequests) ->
    authorizeHttpRequests.requestMatchers(new AntPathRequestMatcher("/**")).permitAll())
    .csrf(csrf -> csrf    //    /h2-console/로 시작하는 모든 URL은 CSRF 검증을 하지 않겠다.
          .ignoringRequestMatchers(new AntPathRequestMatcher("/h2-console/**")))
    .headers(headers -> headers
            .addHeaderWriter(new XFrameOptionsHeaderWriter(
                    XFrameOptionsHeaderWriter.XFrameOptionsMode.SAMEORIGIN)));   
    return http.build();
 }  
 @Bean    //Ioc(Inversion of Control)로 등록.
 PasswordEncoder passwordEncoder() {
     return new BCryptPasswordEncoder();
 }
}
  • UserSerive.java 수정
    package com.mysite.sbb.user;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import lombok.RequiredArgsConstructor;
@RequiredArgsConstructor
@Service
public class UserService {    
  private final UserRepository userRepository;
  private final PasswordEncoder passwordEncoder;
  public SiteUser create(String username, String email, String password) {
      SiteUser user = new SiteUser();
      user.setUsername(username);
      user.setEmail(email);
      // 스프링 시큐리티에서 BCrytPasswordEncoder를 사용
      // 해시함수를 사용하는데 비밀번호 같은 보안 정보를 안전하게 저장하고 검증할 때 사용하는 암호화 기술
      user.setPassword(passwordEncoder.encode(password));
      this.userRepository.save(user);
      return user;
  }
}
  • UserCreateForm.java 생성
    package com.mysite.sbb.user;
import jakarta.validation.constraints.Email;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.Size;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class UserCreateForm {
 @Size(min =3, max =25)
 @NotEmpty(message = "사용자 ID는 필수 항목입니다.")
 private String username;  
 @NotEmpty(message = "비밀번호는 필수 항목입니다.")
 private String password1;
 @NotEmpty(message = "비밀번호는 필수 항목입니다.")
 private String password2;
 @NotEmpty(message = "이메일은 필수 항목입니다.")
 @Email
 private String email;   
}
  • UserController.java 생성
    package com.mysite.sbb.user;
import org.springframework.stereotype.Controller;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
@RequiredArgsConstructor
@Controller
@RequestMapping("/user")
public class UserController {
 private final UserService userService;
 @GetMapping("/signup")
 public String signup(UserCreateForm userCreateForm) {
    return "signup_form";
 }
 @PostMapping("/signup")
 public String signup(@Valid UserCreateForm userCreateForm, BindingResult bindingResult) {
    if (bindingResult.hasErrors()) {
       return "signup_form";
    }
    if (!userCreateForm.getPassword1().equals(userCreateForm.getPassword2())) {
                                       // 필드명, 오류코드, 오류메시지
       bindingResult.rejectValue("password2", "passwordInCorrect", "2개의 패스워드가 일치하지 않습니다.");
       return "signup_form";
    }
    userService.create(userCreateForm.getUsername(), userCreateForm.getEmail(), userCreateForm.getPassword1());     
    return "redirect:/";
 }
}
  • signup_form.html 생성
    <html layout:decorate="~{layout}">
<div layout:fragment="content" class="container my-3">
 <div class="my-3 border-bottom">
    <div>
       <h4>회원가입</h4>
    </div>
 </div>
 <form th:action="@{/user/signup}" th:object="${userCreateForm}" method="post">
    <div th:replace="~{form_errors :: formErrorsFragment}"></div>
    <div class="mb-3">
       <label for="username" class="form-label">사용자ID</label>
       <input type="text" th:field="*{username}" class="form-control">
    </div>
    <div class="mb-3">
       <label for="password1" class="form-label">비밀번호</label>
       <input type="password" th:field="*{password1}" class="form-control">
    </div>
    <div class="mb-3">
       <label for="password2" class="form-label">비밀번호 확인</label>
       <input type="password" th:field="*{password2}" class="form-control">
    </div>
    <div class="mb-3">
       <label for="email" class="form-label">이메일</label>
       <input type="email" th:field="*{email}" class="form-control">
    </div>
    <button type="submit" class="btn btn-primary">회원가입</button>
 </form>
</div>
</html>
  • layout.html 수정
    <!doctype html>
<html lang="ko">
<head>
 <!-- Required meta tags -->
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
 <!-- Bootstrap CSS -->
 <link rel="stylesheet" type="text/css" th:href="@{/bootstrap.min.css}">
 <!-- sbb CSS -->
 <link rel="stylesheet" type="text/css" th:href="@{/style.css}">
 <title>Hello, sbb!</title>
</head>
<body>
 <nav th:fragment="navbarFragment" class="navbar navbar-expand-lg navbar-light bg-light border-bottom">
    <div class="container-fluid">
       <a class="navbar-brand" href="/">SBB</a>
       <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#navbarSupportedContent"
          aria-controls="navbarSupportedContent" aria-expanded="false" aria-label="Toggle navigation">
          <span class="navbar-toggler-icon"></span>
       </button>
       <div class="collapse navbar-collapse" id="navbarSupportedContent">
          <ul class="navbar-nav me-auto mb-2 mb-lg-0">
             <li class="nav-item">
                <a class="nav-link" sec:authorize="isAnonymous()" th:href="@{/user/login}">로그인</a>
                <a class="nav-link" sec:authorize="isAuthenticated()" th:href="@{/user/logout}">로그아웃</a>
             </li>
             <li class="nav-item">
                <a class="nav-link" th:href="@{/user/signup}">회원가입</a>
             </li>
          </ul>
       </div>
    </div>
 </nav>
 <!-- 기본 템플릿 안에 삽입될 내용 Start -->
 <th:block layout:fragment="content"></th:block>
 <!-- 기본 템플릿 안에 삽입될 내용 End -->
</body>
</html>
  • 실행 및 결과

로그인과 로그아웃

<a class="nav-link" sec:authorize="isAnonymous()" th:href="@{/user/login}">로그인</a>
<a class="nav-link" sec:authorize="isAuthenticated()" th:href="@{/user/logout}">로그아웃</a>
  • 로그인하지 않은 상태라면 sec:authorize="isAnonymous()" 가 '참'이 되어 '로그인'링크가 표시되고 로그인한 상태라면 sec:authorize="isAuthenticated()" 가 '참'이 되어 '로그아웃'링크가 표시된다.
  • UserController.java 수정
    package com.mysite.sbb.user;
import org.springframework.dao.DataIntegrityViolationException;
import org.springframework.stereotype.Controller;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
@RequiredArgsConstructor
@Controller
@RequestMapping("/user")
public class UserController {
 private final UserService userService;
 @GetMapping("/signup")
 public String signup(UserCreateForm userCreateForm) {
    return "signup_form";
 }
 @PostMapping("/signup")
 public String signup(@Valid UserCreateForm userCreateForm, BindingResult bindingResult) {
    if (bindingResult.hasErrors()) {
       return "signup_form";
    }
    if (!userCreateForm.getPassword1().equals(userCreateForm.getPassword2())) {                                          // 필드명, 오류코드, 오류메시지
       bindingResult.rejectValue("password2", "passwordInCorrect", "2개의 패스워드가 일치하지 않습니다.");
       return "signup_form";
    }
    try {
    userService.create(userCreateForm.getUsername(), userCreateForm.getEmail(), 
            userCreateForm.getPassword1());
    // 사용자 id 또는 이메일 주소가 이미 존재할 경우에
    } catch (DataIntegrityViolationException e) {
        e.printStackTrace();
        // 필드, 오류코드, 오류메시지
        bindingResult.reject("signupFailed", "이미 등록된 사용자입니다.");
        return "signup_form";
    } catch (Exception e) {
        e.printStackTrace();
        bindingResult.reject("signupFailed", e.getMessage());
        return "signup_form";
    }
    return "redirect:/";
 }
}
  • SecurityConfig.java 수정
    package com.mysite.sbb;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.header.writers.frameoptions.XFrameOptionsHeaderWriter;
import org.springframework.security.web.util.matcher.AntPathRequestMatcher;
@Configuration
@EnableWebSecurity   // 스프링 시큐리티 필터가 스프링 필터체인에 등록이 된다.
public class SecurityConfig {
 @Bean
 SecurityFilterChain filterChain(HttpSecurity http) throws Exception{
    http.authorizeHttpRequests((authorizeHttpRequests) ->
    authorizeHttpRequests.requestMatchers(new AntPathRequestMatcher("/**")).permitAll())
    .csrf(csrf -> csrf   // /h2-console/로 시작하는 모든 URL은 CSRF 검증을 하지 않겠다.
          .ignoringRequestMatchers(new AntPathRequestMatcher("/h2-console/**")))
    .headers(headers -> headers
          .addHeaderWriter(new XFrameOptionsHeaderWriter(
             XFrameOptionsHeaderWriter.XFrameOptionsMode.SAMEORIGIN)))
    .formLogin(formLogin -> formLogin
            .loginPage("/user/login")
            .defaultSuccessUrl("/"));      
    return http.build();
 }   
 @Bean   // Ioc(Inversion of Control)로 등록.
 PasswordEncoder passwordEncoder() {
    return new BCryptPasswordEncoder();
 }
}
    .formLogin(formLogin -> formLogin
            .loginPage("/user/login")
            .defaultSuccessUrl("/"));

  • .formLogin메서드는 스프링 시큐리티의 로그인 설정을 담당하는 메서드. 설정 내용은 로그인 페이지의 url은(/user/login)이고 로그인 성공시에 이동할 페이지를 루트url(/)임을 의미한다.

  • 시큐리티 cycle. 시큐리티가 /user/login 주소 요청이 오면 낚아채서 로그인을 진행시킨다. 로그인을 진행이 완료가 되면 시큐리티 session을 만들어준다.(Security ContextHolder) 오브젝트 타입 => Authentication 타입 객체로 변환 Authentication 안에 User 정보가 있어야 한다. User오브젝트 타입 => UserDetails 타입 객체 즉, Security Session => Authentication => UserDetails(PrincipalDetails)
  • UserController.java 수정
    package com.mysite.sbb.user;
import org.springframework.dao.DataIntegrityViolationException;
import org.springframework.stereotype.Controller;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
@RequiredArgsConstructor
@Controller
@RequestMapping("/user")
public class UserController {
 private final UserService userService;
 @GetMapping("/signup")
 public String signup(UserCreateForm userCreateForm) {
    return "signup_form";
 }
 @PostMapping("/signup")
 public String signup(@Valid UserCreateForm userCreateForm, BindingResult bindingResult) {
    if (bindingResult.hasErrors()) {
       return "signup_form";
    }
    if (!userCreateForm.getPassword1().equals(userCreateForm.getPassword2())) {
                                        // 필드명, 오류코드, 오류메시지
       bindingResult.rejectValue("password2", "passwordInCorrect", "2개의 패스워드가 일치하지 않습니다.");
       return "signup_form";
    }
    try {
    userService.create(userCreateForm.getUsername(), userCreateForm.getEmail(), 
            userCreateForm.getPassword1());
    // 사용자 id 또는 이메일 주소가 이미 존재할 경우에
    } catch (DataIntegrityViolationException e) {
        e.printStackTrace();
        // 필드, 오류코드, 오류메시지
        bindingResult.reject("signupFailed", "이미 등록된 사용자입니다.");
        return "signup_form";
    } catch (Exception e) {
        e.printStackTrace();
        bindingResult.reject("signupFailed", e.getMessage());
        return "signup_form";
    }
    return "redirect:/";
 }   
 @GetMapping("/login")
 public String login() {
     return "login_form";
 }
}
  • login_form.html 생성
    <html layout:decorate="~{layout}">
<div layout:fragment="content" class="container my-3">
 <form th:action="@{/user/login}" method="post">
    <div th:if="${param.error}">
       <div class="alert alert-danger">
          사용자ID 또는 비밀번호를 확인해 주세요.
       </div>
    </div>
    <div class="mb-3">
       <label for="username" class="form-label">사용자ID</label>
       <input type="text" name="username" id="username" class="form-control">
    </div>
    <div class="mb-3">
       <label for="password" class="form-label">비밀번호</label>
       <input type="password" name="password" id="password" class="form-control">
    </div>
    <button type="submit" class="btn btn-primary">로그인</button>
 </form>
</div>
</html>
  • http://localhost:8080/user/login?error .

  • 로그인 실패시 매개변수로 error가 전달되는 것은 스프링 시큐리티의 규칙이다.

  • login_form.html 파일에서
    <div th:if="${param.error}">
       <div class="alert alert-danger">
          사용자ID 또는 비밀번호를 확인해 주세요.
       </div>
    </div>
    의 ${param.error}로 error 매개변수가 전달된다.

  • 스프링 시큐리티에 무엇을 기준으로 로그인해야 하는지 아직 설정하지 않았기 때문, DB에서 사용자를 조회하는 서비스(UserSecurityService)를 만들고, 그 서비스를 스프링 시큐리티에 등록하는 방법

  • UserRepository.java 수정
    package com.mysite.sbb.user;
import java.util.Optional;
import org.springframework.data.jpa.repository.JpaRepository;
public interface UserRepository extends JpaRepository<SiteUser, Long>{
  Optional<SiteUser> findByUsename(String username);
}
  • UserRole.java (enum) 생성
    package com.mysite.sbb.user;
import lombok.Getter;
@Getter
public enum UserRole {
  ADMIN("ROLE_ADMIN"), USER("ROLE_USER");    
  UserRole(String value) {
      this.value=value;
  }    
  private String value;
}

  • 스프링 시큐리티는 인증뿐만 아니라 권한도 관리한다. 스프링 시큐리티는 사용자 인증 후에 사용자에게 부여할 권한과 관련된 처리가 필요하다 우리는 사용자가 로그인한 후, ADMIN인지 USER인지와 같은 권한을 부여해야 한다.

  • UserSecurityService.java 생성
    package com.mysite.sbb.user;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;
import lombok.RequiredArgsConstructor;
@RequiredArgsConstructor
@Service
public class UserSecurityService implements UserDetailsService {
 private final UserRepository userRepository;
// 시큐리티 session(내부 Authentication(내부 UserDetails))
 @Override
 public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
    Optional<SiteUser> _siteUser = this.userRepository.findByUsername(username);
    if (_siteUser.isEmpty()) {
       throw new UsernameNotFoundException("사용자를 찾을수 없습니다.");
    }
    SiteUser siteUser = _siteUser.get();
    // 사용자의 권한 정보
    List<GrantedAuthority> authorities = new ArrayList<>();
    if ("admin".equals(username)) {
       authorities.add(new SimpleGrantedAuthority(UserRole.ADMIN.getValue()));
    } else {
       authorities.add(new SimpleGrantedAuthority(UserRole.USER.getValue()));
    }
    // User 객체 생성, 이 객체는 스프링 시큐리티에서 사용하며 User 생성자에는 id, pw, 권한 리스트가 전달된다
    return new User(siteUser.getUsername(), siteUser.getPassword(), authorities);
 }
}
  • SecurityConfig.java 수정
    package com.mysite.sbb;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.authentication.configuration.AuthenticationConfiguration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.header.writers.frameoptions.XFrameOptionsHeaderWriter;
import org.springframework.security.web.util.matcher.AntPathRequestMatcher;
@Configuration
@EnableWebSecurity   // 스프링 시큐리티 필터가 스프링 필터체인에 등록이 된다.
public class SecurityConfig {
 @Bean
 SecurityFilterChain filterChain(HttpSecurity http) throws Exception{
    http.authorizeHttpRequests((authorizeHttpRequests) ->
    authorizeHttpRequests.requestMatchers(new AntPathRequestMatcher("/**")).permitAll())
    .csrf(csrf -> csrf   // /h2-console/로 시작하는 모든 URL은 CSRF 검증을 하지 않겠다.
          .ignoringRequestMatchers(new AntPathRequestMatcher("/h2-console/**")))
    .headers(headers -> headers
          .addHeaderWriter(new XFrameOptionsHeaderWriter(
             XFrameOptionsHeaderWriter.XFrameOptionsMode.SAMEORIGIN)))
    .formLogin(formLogin -> formLogin
            .loginPage("/user/login")
            .defaultSuccessUrl("/"));  
    return http.build();
 }   
 @Bean   // Ioc(Inversion of Control)로 등록.
 PasswordEncoder passwordEncoder() {
    return new BCryptPasswordEncoder();
 }  
 @Bean    //스프링 시큐리티의 인증을 처리, UserSecurityService와 PasswordEncoder를 내부적으로 사용하여
 // 인증과 권한을 부여 처리한다.
 AuthenticationManager authenticationManager(AuthenticationConfiguration
         authenticationConfiguration) throws Exception{
     return authenticationConfiguration.getAuthenticationManager();
 }
}
  • 실행 및 결과
  • SecurityConfig.java 수정
      package com.mysite.sbb;
  import org.springframework.context.annotation.Bean;
  import org.springframework.context.annotation.Configuration;
  import org.springframework.security.authentication.AuthenticationManager;
  import org.springframework.security.config.annotation.authentication.configuration.AuthenticationConfiguration;
  import org.springframework.security.config.annotation.web.builders.HttpSecurity;
  import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
  import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
  import org.springframework.security.crypto.password.PasswordEncoder;
  import org.springframework.security.web.SecurityFilterChain;
  import org.springframework.security.web.header.writers.frameoptions.XFrameOptionsHeaderWriter;
  import org.springframework.security.web.util.matcher.AntPathRequestMatcher;
  @Configuration
  @EnableWebSecurity   // 스프링 시큐리티 필터가 스프링 필터체인에 등록이 된다.
  public class SecurityConfig {    
     @Bean
     SecurityFilterChain filterChain(HttpSecurity http) throws Exception{
        http.authorizeHttpRequests((authorizeHttpRequests) ->
        authorizeHttpRequests.requestMatchers(new AntPathRequestMatcher("/**")).permitAll())
        .csrf(csrf -> csrf   // /h2-console/로 시작하는 모든 URL은 CSRF 검증을 하지 않겠다.
              .ignoringRequestMatchers(new AntPathRequestMatcher("/h2-console/**")))
        .headers(headers -> headers
              .addHeaderWriter(new XFrameOptionsHeaderWriter(
                 XFrameOptionsHeaderWriter.XFrameOptionsMode.SAMEORIGIN)))
        .formLogin(formLogin -> formLogin
                .loginPage("/user/login")
                .defaultSuccessUrl("/"))
        .logout(logout -> logout
                .logoutRequestMatcher(new AntPathRequestMatcher("/user/logout"))    //로그아웃 url
                .logoutSuccessUrl("/")
                .invalidateHttpSession(true));    // 로그아웃하면 생성된 사용자의 세션도 삭제하도록 해라      
        return http.build();
     }       
     @Bean   // Ioc(Inversion of Control)로 등록.
     PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
     }       
     @Bean    //스프링 시큐리티의 인증을 처리, UserSecurityService와 PasswordEncoder를 내부적으로 사용하여
     // 인증과 권한을 부여 처리한다.
     AuthenticationManager authenticationManager(AuthenticationConfiguration
             authenticationConfiguration) throws Exception{
         return authenticationConfiguration.getAuthenticationManager();
     }
  }
  • 실행 및 결과

  • 질문 또는 답변을 작성할 때 사용자 정보도 DB에 함께 저장되어야 한다. 질문과 답변을 작성할 때 사용자는 반드시 로그인 되어 있어야 한다. 그래야 누가 작성한 글인지 알 수 있고, 수정 및 삭제도 가능하기 때문이다.
  • Question.java 수정
    package com.mysite.sbb.question;
import java.time.LocalDateTime;
import java.util.List;
import com.mysite.sbb.answer.Answer;
import com.mysite.sbb.user.SiteUser;
import jakarta.persistence.CascadeType;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.ManyToOne;
import jakarta.persistence.OneToMany;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@Entity
public class Question {
 @Id
 @GeneratedValue(strategy = GenerationType.IDENTITY)
 private Integer id;
 @Column(length = 200)
 private String subject;
 @Column(columnDefinition = "TEXT")
 private String content;
 private LocalDateTime createDate;   
 @OneToMany(mappedBy = "question", cascade = CascadeType.REMOVE)
 private List<Answer> answerList;   // question.getAnswerList()   
 @ManyToOne
 private SiteUser author;
}
  • Answer.java 수정
    package com.mysite.sbb.answer;
import java.time.LocalDateTime;
import com.mysite.sbb.question.Question;
import com.mysite.sbb.user.SiteUser;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.ManyToOne;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@Entity
public class Answer {
 @Id  // 기본키. 각 데이터들을 구분하는 유효한 값.(중복 불가능)
 @GeneratedValue(strategy = GenerationType.IDENTITY)// 고유한 번호를 생성하는 방법.
 private Integer id;   
 // 열 이름 텍스트를 열 데이터로 넣을수 있다. 글자수를 제한할수 없는 경우에 사용.
 @Column(columnDefinition ="TEXT")
 private String content;   
 private LocalDateTime createDate;    
 // Question를 참조해야 하기 위해.
 @ManyToOne
 private Question question;   
 @ManyToOne
 private SiteUser author;
}
  • AnswerController.java 수정
    package com.mysite.sbb.answer;
import java.security.Principal;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import com.mysite.sbb.question.Question;
import com.mysite.sbb.question.QuestionService;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
@RequestMapping("/answer")
@RequiredArgsConstructor
@Controller
public class AnswerController {
 private final QuestionService questionService;
 private final AnswerService answerService;   
 @PostMapping("/create/{id}")
 public String createAnswer(Model model, @PathVariable("id") Integer id, 
       @Valid AnswerForm answerForm, BindingResult bindingResult, Principal principal) {
    Question question = this.questionService.getQuestion(id);
    if(bindingResult.hasErrors()) {
        model.addAttribute("question", question);
        return "question_detail";
    }
    // TODO: 답변을 저장한다.
    this.answerService.create(question, answerForm.getContent());
    return String.format("redirect:/question/detail/%s", id);
 }
}
    public String createAnswer(Model model, @PathVariable("id") Integer id, 
  @Valid AnswerForm answerForm, BindingResult bindingResult, Principal principal)

  • Principal principal 현재 로그인한 사용자의 정보를 알려면 시큐리티가 제공하는 Principal 객체를 사용해야 한다 principal.getUsername()

  • UserService.java 수정
    package com.mysite.sbb.user;
import java.util.Optional;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import com.mysite.sbb.DataNotFoundException;
import lombok.RequiredArgsConstructor;
@RequiredArgsConstructor
@Service
public class UserService { 
 private final UserRepository userRepository;
 private final PasswordEncoder passwordEncoder; 
 public SiteUser create(String username, String email, String password) {
    SiteUser user = new SiteUser();
    user.setUsername(username);
    user.setEmail(email);
//      스프링시큐리티에서 BCryptPaswerdEncoder를 사용. 
    // 해시함수를 사용하는데 비밀번호 같은 보안 정보를 안전하게 저장하고 검증할때 사용하는 암호화 기술.
    user.setPassword(passwordEncoder.encode(password));
    this.userRepository.save(user);
    return user;
 }   
 public SiteUser getUser(String username) {
    Optional<SiteUser> siteUser = this.userRepository.findByUsername(username);
    if(siteUser.isPresent()) {
       return siteUser.get();               
    }else {
       throw new DataNotFoundException("siteuser not found");
    }
 }
}
  • AnswerService.java 수정
    package com.mysite.sbb.answer;
import java.time.LocalDateTime;
import org.springframework.stereotype.Service;
import com.mysite.sbb.question.Question;
import com.mysite.sbb.user.SiteUser;
import lombok.RequiredArgsConstructor;
@RequiredArgsConstructor
@Service
public class AnswerService {    
  private final AnswerRepository answerRepository;
  public void create(Question question, String content, SiteUser author) {
      Answer answer = new Answer();
      answer.setContent(content);
      answer.setCreateDate(LocalDateTime.now());
      answer.setQuestion(question);
      answer.setAuthor(author);
      this.answerRepository.save(answer);
  }
}
  • AnswerController.java 수정
    package com.mysite.sbb.answer;
import java.security.Principal;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import com.mysite.sbb.question.Question;
import com.mysite.sbb.question.QuestionService;
import com.mysite.sbb.user.SiteUser;
import com.mysite.sbb.user.UserService;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
@RequestMapping("/answer")
@RequiredArgsConstructor
@Controller
public class AnswerController {
 private final QuestionService questionService;
 private final AnswerService answerService;
 private final UserService userService;  
 @PostMapping("/create/{id}")
 public String createAnswer(Model model, @PathVariable("id") Integer id, 
       @Valid AnswerForm answerForm, BindingResult bindingResult, Principal principal) {
    Question question = this.questionService.getQuestion(id);
    SiteUser siteUser = this.userService.getUser(principal.getName());
    if(bindingResult.hasErrors()) {
        model.addAttribute("question", question);
        return "question_detail";
    }
    // TODO: 답변을 저장한다.
    this.answerService.create(question, answerForm.getContent(), siteUser);
    return String.format("redirect:/question/detail/%s", id);
 }
}
  • QuestionService.java 수정
    package com.mysite.sbb.question;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Optional;
import org.springframework.stereotype.Service;
import com.mysite.sbb.DataNotFoundException;
import com.mysite.sbb.user.SiteUser;
import lombok.RequiredArgsConstructor;
@RequiredArgsConstructor
@Service
public class QuestionService {
 private final QuestionRepository questionRepository; 
 public List<Question> getList(){
    return this.questionRepository.findAll();
 }   
 public Question getQuestion(Integer id) {
    Optional<Question> question = this.questionRepository.findById(id);
    if(question.isPresent()) {
       return question.get();
    }else {
       throw new DataNotFoundException("question not found");
    }
 }
 public void create(String subject, String content, SiteUser user) {
    Question q = new Question();
    q.setSubject(subject);
    q.setContent(content);
    q.setCreateDate(LocalDateTime.now());
    q.setAuthor(user);
    this.questionRepository.save(q);
 }
}
  • QuestionController.java 수정
    package com.mysite.sbb.question;
import java.security.Principal;
import java.util.List;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import com.mysite.sbb.answer.AnswerForm;
import com.mysite.sbb.user.SiteUser;
import com.mysite.sbb.user.UserService;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
@RequestMapping("/question")
@RequiredArgsConstructor
@Controller
public class QuestionController {   
 private final QuestionService questionService;
 private final UserService userService;   
 @GetMapping("/list")
 public String list(Model model) {
    List<Question> questionList = this.questionService.getList();
    model.addAttribute("questionList", questionList);
    return "question_list";
 }   
 @GetMapping(value = "/detail/{id}")
 public String detail(Model model, @PathVariable("id") Integer id, AnswerForm answerForm) {
    Question question = this.questionService.getQuestion(id);
    model.addAttribute("question",question);
    return "question_detail";
 }   
 @GetMapping("/create")
 public String questionCreate(QuestionForm questionForm) {
    return "question_form";
 }
 @PostMapping("/create")
 public String questionCreate(@Valid QuestionForm questionForm, BindingResult bindingResult, Principal principal ) {
    if(bindingResult.hasErrors()) {
       return "question_form";
    }
    SiteUser siteUser = this.userService.getUser(principal.getName());
    this.questionService.create(questionForm.getSubject(), questionForm.getContent(), siteUser);
    return "redirect:/question/list";   // 질문 저장후 질문 목록으로 이동
 }
}
  • SbbAplicationTests.java 수정
    package com.mysite.sbb;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import com.mysite.sbb.question.QuestionService;
@SpringBootTest
class SbbApplicationTests {
  @Autowired
  private QuestionService questionService;
  @Test
  void testJpa() {
      for (int i = 1; i <= 300; i++) {
          String subject = String.format("테스트 데이터입니다:[%03d]", i);
          String content = "내용무";
          this.questionService.create(subject, content, null);
      }
  }
}
  • 실행 및 결과

    로그아웃 상태에서 답변을 달 경우

  • because "principal" is null 오류 principal 객체는 로그인을 해야만 생성되는 객체인데 현재는 로그아웃 상태이므로 principal 객체에 값이 없어 오류가 발생

  • 해결하려면Authenticated: 인증됨 @PreAuthorize("isAuthenticated()") 로그인한 경우에만 실행한다. 로그인한 사용자만 호출할 수 있다.

  • QuestionController.java 수정
    package com.mysite.sbb.question;
import java.security.Principal;
import java.util.List;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import com.mysite.sbb.answer.AnswerForm;
import com.mysite.sbb.user.SiteUser;
import com.mysite.sbb.user.UserService;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
@RequestMapping("/question")
@RequiredArgsConstructor
@Controller
public class QuestionController {   
 private final QuestionService questionService;
 private final UserService userService;
 @GetMapping("/list")
 public String list(Model model) {
    List<Question> questionList = this.questionService.getList();
    model.addAttribute("questionList", questionList);
    return "question_list";
 }   
 @GetMapping(value = "/detail/{id}")
 public String detail(Model model, @PathVariable("id") Integer id, AnswerForm answerForm) {
    Question question = this.questionService.getQuestion(id);
    model.addAttribute("question",question);
    return "question_detail";
 }
 @PreAuthorize("isAuthenticated()")
 @GetMapping("/create")
 public String questionCreate(QuestionForm questionForm) {
    return "question_form";
 }  
 @PreAuthorize("isAuthenticated()")// 로그아웃상태에서 호출하면 로그인페이지로 강제 이동.
 @PostMapping("/create")
 public String questionCreate(@Valid QuestionForm questionForm, BindingResult bindingResult, Principal principal ) {
    if(bindingResult.hasErrors()) {
       return "question_form";
    }
    SiteUser siteUser = this.userService.getUser(principal.getName());
    this.questionService.create(questionForm.getSubject(), questionForm.getContent(), siteUser);
    return "redirect:/question/list";   // 질문 저장후 질문 목록으로 이동
 }
}
  • AnswerController.java 수정
    package com.mysite.sbb.answer;
import java.security.Principal;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import com.mysite.sbb.question.Question;
import com.mysite.sbb.question.QuestionService;
import com.mysite.sbb.user.SiteUser;
import com.mysite.sbb.user.UserService;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
@RequestMapping("/answer")
@RequiredArgsConstructor
@Controller
public class AnswerController {
 private final QuestionService questionService;
 private final AnswerService answerService;
 private final UserService userService;   
 @PreAuthorize("isAuthenticated()")
 @PostMapping("/create/{id}")
 public String createAnswer(Model model, @PathVariable("id") Integer id, 
       @Valid AnswerForm answerForm, BindingResult bindingResult, Principal principal) {
    Question question = this.questionService.getQuestion(id);
    SiteUser siteUser = this.userService.getUser(principal.getName());
    if(bindingResult.hasErrors()) {
        model.addAttribute("question", question);
        return "question_detail";
    }
    // TODO: 답변을 저장한다.
    this.answerService.create(question, answerForm.getContent(), siteUser);
    return String.format("redirect:/question/detail/%s", id);
 }
}
  • SecurityConfig 수정
      package com.mysite.sbb;    
  import org.springframework.context.annotation.Bean;
  import org.springframework.context.annotation.Configuration;
  import org.springframework.security.authentication.AuthenticationManager;
  import org.springframework.security.config.annotation.authentication.configuration.AuthenticationConfiguration;
import org.springframework.security.config.annotation.method.configuration.EnableMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
  import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
  import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
  import org.springframework.security.crypto.password.PasswordEncoder;
  import org.springframework.security.web.SecurityFilterChain;
  import org.springframework.security.web.header.writers.frameoptions.XFrameOptionsHeaderWriter;
  import org.springframework.security.web.util.matcher.AntPathRequestMatcher;    
  @Configuration
  @EnableWebSecurity      // 스프링 시큐리티 필터가 스프링 필터체인에 등록이 된다.
  @EnableMethodSecurity(prePostEnabled = true)
  public class SecurityConfig {    
     @Bean
     SecurityFilterChain filterChain(HttpSecurity http) throws Exception{
        http.authorizeHttpRequests((authorizeHttpRequests) ->
        authorizeHttpRequests.requestMatchers(new AntPathRequestMatcher("/**")).permitAll())
        .csrf(csrf -> csrf   // /h2-console/로 시작하는 모든 URL은 CSRF 검증을 하지 않겠다.
              .ignoringRequestMatchers(new AntPathRequestMatcher("/h2-console/**")))
        .headers(headers -> headers
              .addHeaderWriter(new XFrameOptionsHeaderWriter(
                 XFrameOptionsHeaderWriter.XFrameOptionsMode.SAMEORIGIN)))
        .formLogin(formLogin -> formLogin
                .loginPage("/user/login")
                .defaultSuccessUrl("/"))
        .logout(logout -> logout
                .logoutRequestMatcher(new AntPathRequestMatcher("/user/logout"))    //로그아웃 url
                .logoutSuccessUrl("/")
                .invalidateHttpSession(true));    // 로그아웃하면 생성된 사용자의 세션도 삭제하도록 해라          
        return http.build();
     }       
     @Bean   // Ioc(Inversion of Control)로 등록.
     PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
     }       
     @Bean    //스프링 시큐리티의 인증을 처리, UserSecurityService와 PasswordEncoder를 내부적으로 사용하여
     // 인증과 권한을 부여 처리한다.
     AuthenticationManager authenticationManager(AuthenticationConfiguration
             authenticationConfiguration) throws Exception{
         return authenticationConfiguration.getAuthenticationManager();
     }    
  }

  • @EnableMethodSecurity(prePostEnabled = true) 시큐리티의 보안기능을 활성화하고 @PreAuthorieze, @PostAuthorize을 사용할 수 있게 한다.

  • 질문 등록페이지에서는 사용자가 로그아웃 상태라면 아예 글을 작성할 수 없다. 하지만 답변 등록 페이지에서는 로그아웃 상태에서도 글을 작성할 수 있어서 답변을 작성한 후 등록버튼으 누르면 로그인 화면으로 이동된다. 이렇게 되면 문제가 사용자가 작성한 답변이 사라지는 경우가 있다. 이 문제를 해결하기 위한 방법으로 사용자가 로그아웃 상태인 경우 아예 답변 작성을 못하도록 막는 것으로 처리한다.

->

  • question_detail.html 수정
    <html layout:decorate="~{layout}">
<div layout:fragment="content" class="container my-3">
 <!-- 질문-->
 <h2 class="border-bottom py-2" th:text="${question.subject}"></h2> 
 <div class="card my-3">
    <div class="card-body">
       <div class="card-text" style="white-space: pre-line;" th:text="${question.content}"></div>
       <div class="d-flex justify-content-end">
          <div class="badge bg-light text-dark p-2 text-start">
              <div th:text="${#temporals.format(question.createDate, 'yyyy-MM-dd HH:mm')}"></div>
          </div>
       </div>
       </div>
    </div>
 <!-- 답변 개수 표시 -->
 <h5 class="border-bottom my-3 py-2" th:text="|${#lists.size(question.answerList)}개의 답변이 있습니다.|"></h5>
 <!-- 답변 반복 시작 -->
 <div class="card my-3" th:each="answer: ${question.answerList}">
    <div class="card-body">
       <div class="card-text" style="white-space:pre-line;" th:text="${answer.content}"></div>
       <div class="d-flex justify-content-end">
          <div class="badge bg-light text-dark p-2 text-start"> 
             <div th:text="${#temporals.format(answer.createDate, 'yyyy-MM-dd HH:mm')}"></div>      
          </div>
       </div>
       </div>
    </div>
 <!-- 답변 반복 끝 -->
 <!-- 답변 작성-->
 <form th:action="@{|/answer/create/${question.id}|}" th:object="${answerForm}" method="post" class="my-3">
    <div th:replace="~{form_errors :: formErrorsFragment}"></div>
    <textarea sec:authorize="isAnonymous()" disabled th:field="*{content}" 
             class="form-control" rows="10"></textarea>
       <textarea sec:authorize="isAuthenticated()" th:field="*{content}" 
          class="form-control" rows="10"></textarea>            
       <input type="submit" value="답변 등록" class="btn btn-primary my-2"> </form>
 </div>
 </html>
        <textarea sec:authorize="isAnonymous()" disabled th:field="*{content}" 
             class="form-control" rows="10"></textarea>
       <textarea sec:authorize="isAuthenticated()" th:field="*{content}" 
          class="form-control" rows="10"></textarea>

  • 로그인 상태가 아닌 경우 textarea 태그에 disable 속성을 넣어 사용자가 화면에서 아예 입력하지 못하게 만든다. sec:authorize="isAnonymous()" : 로그아웃 상태 sec:authorize="isAuthenticated()" : 로그인 상태

  • question_list.html 수정
    <html layout:decorate="~{layout}">
<div layout:fragment="content" class="container my-3">
<table class="table">
 <thead class="table-dark">
    <tr class="text-center">
             <th>번호</th>
             <th style="width: 50%">제목</th>
             <th>글쓴이</th>
             <th>작성일시</th>
          </tr>
 </thead>
 <tbody>
    <tr th:each="question, loop : ${questionList}">
       <td th:text="${loop.count}"></td>
       <td class="text-start">
                   <a th:href="@{|/question/detail/${question.id}|}"
                   th:text="${question.subject}"></a>
                </td> 
       <td><span th:if="${question.author !=null}" 
          th:text="${question.author.username}"></span></td>
       <td th:text="${#temporals.format(question.createDate,'yyyy-MM-dd HH:mm')}"></td>
    </tr>
 </tbody>
</table>
<a th:href="@{/question/create}" class = "btn btn-primary">질문 등록하기</a>
</div>
</html>
  • question_detail.html 수정
    <html layout:decorate="~{layout}">
<div layout:fragment="content" class="container my-3">
 <!-- 질문-->
 <h2 class="border-bottom py-2" th:text="${question.subject}"></h2> 
 <div class="card my-3">
    <div class="card-body">
       <div class="card-text" style="white-space: pre-line;" th:text="${question.content}"></div>
       <div class="d-flex justify-content-end">
          <div class="badge bg-light text-dark p-2 text-start">
             <div class="mb-2">
                               <span th:if="${question.author != null}"
                               th:text ="${question.author.username}"></span>
                            </div>
              <div th:text="${#temporals.format(question.createDate, 'yyyy-MM-dd HH:mm')}"></div>
          </div>
       </div>
       </div>
    </div>
 <!-- 답변 개수 표시 -->
 <h5 class="border-bottom my-3 py-2" th:text="|${#lists.size(question.answerList)}개의 답변이 있습니다.|"></h5>
 <!-- 답변 반복 시작 -->
 <div class="card my-3" th:each="answer: ${question.answerList}">
    <div class="card-body">
       <div class="card-text" style="white-space:pre-line;" th:text="${answer.content}"></div>
       <div class="d-flex justify-content-end">
          <div class="badge bg-light text-dark p-2 text-start"> 
             <div class="mb-2">
                               <span th:if="${answer.author != null}"
                               th:text ="${answer.author.username}"></span>
                            </div>
             <div th:text="${#temporals.format(answer.createDate, 'yyyy-MM-dd HH:mm')}"></div>      
          </div>
       </div>
       </div>
    </div>
 <!-- 답변 반복 끝 -->
 <!-- 답변 작성-->
 <form th:action="@{|/answer/create/${question.id}|}" th:object="${answerForm}" method="post" class="my-3">
    <div th:replace="~{form_errors :: formErrorsFragment}"></div>      
    <textarea sec:authorize="isAnonymous()" disabled th:field="*{content}" 
             class="form-control" rows="10"></textarea>
       <textarea sec:authorize="isAuthenticated()" th:field="*{content}" 
          class="form-control" rows="10"></textarea>           
       <input type="submit" value="답변 등록" class="btn btn-primary my-2"> </form>
 </div>
 </html>
  • 실행 및 결과

  • 작성자가 표시된다

질문 또는 답변을 작성한 후 글들을 수정하거나 삭제할 수 있어야 한다

  • Question.java 수정
    package com.mysite.sbb.question;
import java.time.LocalDateTime;
import java.util.List;
import com.mysite.sbb.answer.Answer;
import com.mysite.sbb.user.SiteUser;
import jakarta.persistence.CascadeType;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.ManyToOne;
import jakarta.persistence.OneToMany;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@Entity
public class Question {
 @Id
 @GeneratedValue(strategy = GenerationType.IDENTITY)
 private Integer id;
 @Column(length = 200)
 private String subject;
 @Column(columnDefinition = "TEXT")
 private String content;
 private LocalDateTime createDate;  
 @OneToMany(mappedBy = "question", cascade = CascadeType.REMOVE)
 private List<Answer> answerList;   // question.getAnswerList()   
 @ManyToOne
 private SiteUser author;  
 private LocalDateTime modifyDate;
}
  • Answer.java 수정
    package com.mysite.sbb.answer;
import java.time.LocalDateTime;
import com.mysite.sbb.question.Question;
import com.mysite.sbb.user.SiteUser;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.ManyToOne;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@Entity
public class Answer {
 @Id  // 기본키. 각 데이터들을 구분하는 유효한 값.(중복 불가능)
 @GeneratedValue(strategy = GenerationType.IDENTITY)// 고유한 번호를 생성하는 방법.
 private Integer id;   
 // 열 이름 텍스트를 열 데이터로 넣을수 있다. 글자수를 제한할수 없는 경우에 사용.
 @Column(columnDefinition ="TEXT")
 private String content;   
 private LocalDateTime createDate;     
 // Question를 참조해야 하기 위해.
 @ManyToOne
 private Question question;   
 @ManyToOne
 private SiteUser author;   
 private LocalDateTime modifyDate;
}
  • question_detail.html 수정
    <html layout:decorate="~{layout}">
<div layout:fragment="content" class="container my-3">
 <!-- 질문-->
 <h2 class="border-bottom py-2" th:text="${question.subject}"></h2> 
 <div class="card my-3">
    <div class="card-body">
       <div class="card-text" style="white-space: pre-line;" th:text="${question.content}"></div>
       <div class="d-flex justify-content-end">
          <div class="badge bg-light text-dark p-2 text-start">
             <div class="mb-2">
                               <span th:if="${question.author != null}"
                               th:text ="${question.author.username}"></span>
                            </div>
              <div th:text="${#temporals.format(question.createDate, 'yyyy-MM-dd HH:mm')}"></div>
          </div>
       </div>
       </div>
       <div class="my-3">                           
          <a th:href="@{|/question/modify/${question.id}|}" class="btn btn-sm btn-outline-secondary"
                sec:authorize="isAuthenticated()" 
                th:if="${question.author != null and #authentication.getPrincipal().getUsername() == question.author.username}" th:text="수정"></a>
                                     </div>
                </div>    
 <!-- 답변 개수 표시 -->
 <h5 class="border-bottom my-3 py-2" th:text="|${#lists.size(question.answerList)}개의 답변이 있습니다.|"></h5>
 <!-- 답변 반복 시작 -->
 <div class="card my-3" th:each="answer: ${question.answerList}">
    <div class="card-body">
       <div class="card-text" style="white-space:pre-line;" th:text="${answer.content}"></div>
       <div class="d-flex justify-content-end">
          <div class="badge bg-light text-dark p-2 text-start"> 
             <div class="mb-2">
                               <span th:if="${answer.author != null}"
                               th:text ="${answer.author.username}"></span>
                            </div>
             <div th:text="${#temporals.format(answer.createDate, 'yyyy-MM-dd HH:mm')}"></div>      
          </div>
       </div>
       </div>
    </div>
 <!-- 답변 반복 끝 -->
 <!-- 답변 작성-->
 <form th:action="@{|/answer/create/${question.id}|}" th:object="${answerForm}" method="post" class="my-3">
    <div th:replace="~{form_errors :: formErrorsFragment}"></div>    
    <textarea sec:authorize="isAnonymous()" disabled th:field="*{content}" 
             class="form-control" rows="10"></textarea>
       <textarea sec:authorize="isAuthenticated()" th:field="*{content}" 
          class="form-control" rows="10"></textarea>            
       <input type="submit" value="답변 등록" class="btn btn-primary my-2"> </form>
 </div>
 </html>
  • #authentication.getPrincipal().getUsername() == question.author.username #authentication.getPrincipal()은 타임리프에서 스프링 시큐리티와 함께 사용하는 표현식으로 현재 사용자가 인증되었다면 사용자 이름(id)을 알 수 있다. 로그인한 사용자와 글쓴이가 같다면 수정버튼이 보여라.
  • QuestionController.java 수정
    package com.mysite.sbb.question;
import java.security.Principal;
import java.util.List;
import org.springframework.http.HttpStatus;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.server.ResponseStatusException;
import com.mysite.sbb.answer.AnswerForm;
import com.mysite.sbb.user.SiteUser;
import com.mysite.sbb.user.UserService;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
@RequestMapping("/question")
@RequiredArgsConstructor
@Controller
public class QuestionController {   
 private final QuestionService questionService;
 private final UserService userService;  
 @GetMapping("/list")
 public String list(Model model) {
    List<Question> questionList = this.questionService.getList();
    model.addAttribute("questionList", questionList);
    return "question_list";
 }  
 @GetMapping(value = "/detail/{id}")
 public String detail(Model model, @PathVariable("id") Integer id, AnswerForm answerForm) {
    Question question = this.questionService.getQuestion(id);
    model.addAttribute("question",question);
    return "question_detail";
 }   
 @PreAuthorize("isAuthenticated()")
 @GetMapping("/create")
 public String questionCreate(QuestionForm questionForm) {
    return "question_form";
 }   
 @PreAuthorize("isAuthenticated()")// 로그아웃상태에서 호출하면 로그인페이지로 강제 이동.
 @PostMapping("/create")
 public String questionCreate(@Valid QuestionForm questionForm, BindingResult bindingResult, Principal principal ) {
    if(bindingResult.hasErrors()) {
       return "question_form";
    }
    SiteUser siteUser = this.userService.getUser(principal.getName());
    this.questionService.create(questionForm.getSubject(), questionForm.getContent(), siteUser);
    return "redirect:/question/list";   // 질문 저장후 질문 목록으로 이동
 }  
 @PreAuthorize("isAuthenticated()")
 @GetMapping("/modify/{id}")
 public String questionModify(QuestionForm questionForm, @PathVariable("id") Integer id, 
       Principal principal) {
    Question question = this.questionService.getQuestion(id);
    if (!question.getAuthor().getUsername().equals(principal.getName())) {
       throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "수정권한이 없습니다.");
    }
    questionForm.setSubject(question.getSubject());
    questionForm.setContent(question.getContent());
    return "question_form";
 }
}
  • 실행 및 결과

  • 수정 후 시간 변화

  • question_form.html 수정
    <html layout:decorate="~{layout}">
<div layout:fragment="content" class="container">
 <h5 class="my-3 border-bottom pb-2">질문등록</h5>
 <form th:object="${questionForm}" method="post">
       <input type="hidden" th:name="${_csrf.parameterName}" th:value="${_csrf.token}" />
       <div th:replace="~{form_errors :: formErrorsFragment}"></div>
    <div class="alert alert-danger" role="alert" th:if="${#fields.hasAnyErrors()}">
       <div th:each="err : ${#fields.allErrors()}" th:text="${err}" />
    </div>
    <div class="mb-3">
       <label for="subject" class="form-label">제목</label>
       <input type="text" th:field="*{subject}" id="subject" class="form-control">
    </div>
    <div class="mb-3">
       <label for="content" class="form-label">내용</label>
       <textarea th:field="*{content}" id="content" class="form-control" rows="10"></textarea>
    </div>
    <input type="submit" value="저장하기" class="btn btn-primary my-2">
 </form>
</div>
</html>
    <form th:object="${questionForm}" method="post">
 <input type="hidden" th:name="${_csrf.parameterName}" th:value="${_csrf.token}" />

  • 기존에 있던 [form]의 action 속성을 삭제했다. action을 삭제하면 CSRF값이 자동으로 생성되지 않아서 CSRF값을 설정하기 위해 hidden 형태로 input 요소를 같이 추가한다 == CSRF값을 수동으로 추가해야 하는 이유는 스프링 시큐리티를 사용할때 CSRF 값이 반드시 필요하기 때문이다.

  • QuestionService.java 수정
    package com.mysite.sbb.question;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Optional;
import org.springframework.stereotype.Service;
import com.mysite.sbb.DataNotFoundException;
import com.mysite.sbb.user.SiteUser;
import lombok.RequiredArgsConstructor;
@RequiredArgsConstructor
@Service
public class QuestionService {
 private final QuestionRepository questionRepository; 
 public List<Question> getList(){
    return this.questionRepository.findAll();
 }   
 public Question getQuestion(Integer id) {
    Optional<Question> question = this.questionRepository.findById(id);
    if(question.isPresent()) {
       return question.get();
    }else {
       throw new DataNotFoundException("question not found");
    }
 }
 public void create(String subject, String content, SiteUser user) {
    Question q = new Question();
    q.setSubject(subject);
    q.setContent(content);
    q.setCreateDate(LocalDateTime.now());
    q.setAuthor(user);
    this.questionRepository.save(q);
 }
 public void modify(Question question, String subject, String content) {
     question.setSubject(subject);
     question.setContent(content);
     question.setModifyDate(LocalDateTime.now());
     this.questionRepository.save(question);
 }
}
  • QuestionController.java 수정
    package com.mysite.sbb.question;
import java.security.Principal;
import java.util.List;
import org.springframework.http.HttpStatus;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.server.ResponseStatusException;
import com.mysite.sbb.answer.AnswerForm;
import com.mysite.sbb.user.SiteUser;
import com.mysite.sbb.user.UserService;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
@RequestMapping("/question")
@RequiredArgsConstructor
@Controller
public class QuestionController {
 private final QuestionService questionService;
 private final UserService userService;   
 @GetMapping("/list")
 public String list(Model model) {
    List<Question> questionList = this.questionService.getList();
    model.addAttribute("questionList", questionList);
    return "question_list";
 }   
 @GetMapping(value = "/detail/{id}")
 public String detail(Model model, @PathVariable("id") Integer id, AnswerForm answerForm) {
    Question question = this.questionService.getQuestion(id);
    model.addAttribute("question",question);
    return "question_detail";
 }   
 @PreAuthorize("isAuthenticated()")
 @GetMapping("/create")
 public String questionCreate(QuestionForm questionForm) {
    return "question_form";
 }   
 @PreAuthorize("isAuthenticated()")// 로그아웃상태에서 호출하면 로그인페이지로 강제 이동.
 @PostMapping("/create")
 public String questionCreate(@Valid QuestionForm questionForm, BindingResult bindingResult, Principal principal ) {
    if(bindingResult.hasErrors()) {
       return "question_form";
    }
    SiteUser siteUser = this.userService.getUser(principal.getName());
    this.questionService.create(questionForm.getSubject(), questionForm.getContent(), siteUser);
    return "redirect:/question/list";   // 질문 저장후 질문 목록으로 이동
 }   
 @PreAuthorize("isAuthenticated()")
 @GetMapping("/modify/{id}")
 public String questionModify(QuestionForm questionForm, @PathVariable("id") Integer id, 
       Principal principal) {
    Question question = this.questionService.getQuestion(id);
    if (!question.getAuthor().getUsername().equals(principal.getName())) {
       throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "수정권한이 없습니다.");
    }
    questionForm.setSubject(question.getSubject());
    questionForm.setContent(question.getContent());
    return "question_form";
 }   
 @PreAuthorize("isAuthenticated()")
 @PostMapping("/modify/{id}")
 public String questionModify(@Valid QuestionForm questionForm, BindingResult bindingResult, Principal principal,
       @PathVariable("id") Integer id) {
    if (bindingResult.hasErrors()) {
       return "question_form";
    }
    Question question = this.questionService.getQuestion(id);
    if (!question.getAuthor().getUsername().equals(principal.getName())) {
       throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "수정권한이 없습니다.");
    }
    this.questionService.modify(question, questionForm.getSubject(), 
          questionForm.getContent());
    return String.format("redirect:/question/detail/%s", id);
 }
}
  • 실행 및 결과

삭제버튼 추가

  • question_detail.html 수정
    <html layout:decorate="~{layout}">
<div layout:fragment="content" class="container my-3">
 <!-- 질문-->
 <h2 class="border-bottom py-2" th:text="${question.subject}"></h2> 
 <div class="card my-3">
    <div class="card-body">
       <div class="card-text" style="white-space: pre-line;" th:text="${question.content}"></div>
       <div class="d-flex justify-content-end">
          <div class="badge bg-light text-dark p-2 text-start">
             <div class="mb-2">
                               <span th:if="${question.author != null}"
                               th:text ="${question.author.username}"></span>
                            </div>
              <div th:text="${#temporals.format(question.createDate, 'yyyy-MM-dd HH:mm')}"></div>
          </div>
       </div>
       </div>
       <div class="my-3">                           
          <a th:href="@{|/question/modify/${question.id}|}" class="btn btn-sm btn-outline-secondary"
                sec:authorize="isAuthenticated()" 
                th:if="${question.author != null and #authentication.getPrincipal().getUsername() == question.author.username}" th:text="수정"></a>
                <a href="javascript:void(0);" th:data-uri="@{|/question/delete/${question.id}|}"
                               class="delete btn btn-sm btn-outline-secondary" sec:authorize="isAuthenticated()"
                               th:if="${question.author != null and #authentication.getPrincipal().getUsername() == question.author.username}"
                               th:text="삭제"></a>     
                                </div>
                </div>      
 <!-- 답변 개수 표시 -->
 <h5 class="border-bottom my-3 py-2" th:text="|${#lists.size(question.answerList)}개의 답변이 있습니다.|"></h5>
 <!-- 답변 반복 시작 -->
 <div class="card my-3" th:each="answer: ${question.answerList}">
    <div class="card-body">
       <div class="card-text" style="white-space:pre-line;" th:text="${answer.content}"></div>
       <div class="d-flex justify-content-end">
          <div class="badge bg-light text-dark p-2 text-start"> 
             <div class="mb-2">
                               <span th:if="${answer.author != null}"
                               th:text ="${answer.author.username}"></span>
                            </div>
             <div th:text="${#temporals.format(answer.createDate, 'yyyy-MM-dd HH:mm')}"></div>    
          </div>
       </div>
       </div>
    </div>
 <!-- 답변 반복 끝 -->
 <!-- 답변 작성-->
 <form th:action="@{|/answer/create/${question.id}|}" th:object="${answerForm}" method="post" class="my-3">
    <div th:replace="~{form_errors :: formErrorsFragment}"></div>      
    <textarea sec:authorize="isAnonymous()" disabled th:field="*{content}" 
             class="form-control" rows="10"></textarea>
       <textarea sec:authorize="isAuthenticated()" th:field="*{content}" 
          class="form-control" rows="10"></textarea>
       <input type="submit" value="답변 등록" class="btn btn-primary my-2"> </form>
 </div>
 </html>

  • 로그인한 사용자가 자신이 작성한 질문을 삭제할 수 있도록 [삭제]버튼을 클릭하면 자바스크립트 임시링크의 코드가 실행되도록 구현했다. [삭제]버튼은 [수정]버튼과 달리 href속성값을 javascript.void(0)로 설정해서 삭제를 실행할 url을 얻기위해 th:data-uri 속성을 추가한 뒤, [삭제] 버튼을 클릭하는 이벤트를 확인하기 위해 class 속성에 delete항목을 추가한 것 href에 삭제를 위한 url을 직접 사용하지 않고 이러한 방식을 사용한 이유는 [삭제]버튼을 클릭했을때 '삭제하시겠습니까?'와 같은 메시지와 함께 별도의 호가인 절차를 중간에 끼워 넣기 위해서이다. (data-uri: 속성에 설정한 값은 클릭 이벤트 발생 시 자바스크립트 코드에서 this.dataset.uri를 사용하여 그 값을 알아서 실행할 수 있다.) 삭제 작업을 수행하는데 실제 url을 data_uri에 저장된다. 사용자가 링크를 클릭하면 자바스크립트 함수가 이 data-uri 속성에서 url을 가져와 ajax 호출 또는 다른 형태의 요청을 통해 페이지를 새로 고치지 않고 질문을 삭제할 수 있다.

    <script type='text/javascript">
const delete_elements = document.getElementsByClassName("delete");
Array.from(delete_elements).forEach(function(element) { element.addEventListener('click', function() {
  if(confirm("정말로 삭제하시겠습니까?")) {
     location.href= this.dataset.uri;   // [확인]을 클릭했을 경우 삭제를 위한 url을 호출하기 위해 작성.
  };
    });
});
</script>
    • layout.html 수정
      <!doctype html>
<html lang="ko">
<head>
<!-- Required meta tags -->
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
<!-- Bootstrap CSS -->
<link rel="stylesheet" type="text/css" th:href="@{/bootstrap.min.css}">
<!-- sbb CSS -->
<link rel="stylesheet" type="text/css" th:href="@{/style.css}">
<title>Hello, sbb!</title>
</head>
<body>
<nav th:fragment="navbarFragment" class="navbar navbar-expand-lg navbar-light bg-light border-bottom">
   <div class="container-fluid">
      <a class="navbar-brand" href="/">SBB</a>
      <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#navbarSupportedContent"
         aria-controls="navbarSupportedContent" aria-expanded="false" aria-label="Toggle navigation">
         <span class="navbar-toggler-icon"></span>
      </button>
      <div class="collapse navbar-collapse" id="navbarSupportedContent">
         <ul class="navbar-nav me-auto mb-2 mb-lg-0">
            <li class="nav-item">
               <a class="nav-link" sec:authorize="isAnonymous()" th:href="@{/user/login}">로그인</a>
               <a class="nav-link" sec:authorize="isAuthenticated()" th:href="@{/user/logout}">로그아웃</a>
            </li>
            <li class="nav-item">
               <a class="nav-link" th:href="@{/user/signup}">회원가입</a>
            </li>
         </ul>
      </div>
   </div>
</nav>
<!-- 기본 템플릿 안에 삽입될 내용 Start -->
<th:block layout:fragment="content"></th:block>
<!-- 기본 템플릿 안에 삽입될 내용 End -->
<!-- 자바스크립트 Start -->
   <th:block layout:fragment="script"></th:block>
   <!-- 자바스크립트 End -->
</body>
</html>
      <html layout:decorate="~{layout}">
<div layout:fragment="content" class="container my-3">
<!-- 질문-->
<h2 class="border-bottom py-2" th:text="${question.subject}"></h2> 
<div class="card my-3">
   <div class="card-body">
      <div class="card-text" style="white-space: pre-line;" th:text="${question.content}"></div>
      <div class="d-flex justify-content-end">
         <div class="badge bg-light text-dark p-2 text-start">
            <div class="mb-2">
                              <span th:if="${question.author != null}"
                              th:text ="${question.author.username}"></span>
                           </div>
             <div th:text="${#temporals.format(question.createDate, 'yyyy-MM-dd HH:mm')}"></div>
         </div>
      </div>
      </div>
      <div class="my-3">                           
         <a th:href="@{|/question/modify/${question.id}|}" class="btn btn-sm btn-outline-secondary"
               sec:authorize="isAuthenticated()" 
               th:if="${question.author != null and #authentication.getPrincipal().getUsername() == question.author.username}" th:text="수정"></a>
         <a href="javascript:void(0);" th:data-uri="@{|/question/delete/${question.id}|}"
                              class="delete btn btn-sm btn-outline-secondary" sec:authorize="isAuthenticated()"
                              th:if="${question.author != null and #authentication.getPrincipal().getUsername() == question.author.username}"
                              th:text="삭제"></a>   
                                    </div>
               </div>
<!-- 답변 개수 표시 -->
<h5 class="border-bottom my-3 py-2" th:text="|${#lists.size(question.answerList)}개의 답변이 있습니다.|"></h5>
<!-- 답변 반복 시작 -->
<div class="card my-3" th:each="answer: ${question.answerList}">
   <div class="card-body">
      <div class="card-text" style="white-space:pre-line;" th:text="${answer.content}"></div>
      <div class="d-flex justify-content-end">
         <div class="badge bg-light text-dark p-2 text-start"> 
            <div class="mb-2">
                              <span th:if="${answer.author != null}"
                              th:text ="${answer.author.username}"></span>
                           </div>
            <div th:text="${#temporals.format(answer.createDate, 'yyyy-MM-dd HH:mm')}"></div>    
         </div>
      </div>
      </div>
   </div>
<!-- 답변 반복 끝 -->
<!-- 답변 작성-->
<form th:action="@{|/answer/create/${question.id}|}" th:object="${answerForm}" method="post" class="my-3">
   <div th:replace="~{form_errors :: formErrorsFragment}"></div>      
   <textarea sec:authorize="isAnonymous()" disabled th:field="*{content}" 
            class="form-control" rows="10"></textarea>
      <textarea sec:authorize="isAuthenticated()" th:field="*{content}" 
         class="form-control" rows="10"></textarea>          
      <input type="submit" value="답변 등록" class="btn btn-primary my-2"> </form>
</div>
<script layout:fragment="script" type='text/javascript'>
   const delete_elements = document.getElementsByClassName("delete");
   Array.from(delete_elements).forEach(function (element) {
      element.addEventListener('click', function () {
         if (confirm("정말로 삭제하시겠습니까?")) {
            location.href = this.dataset.uri;
         };
      });
   });
</script>
</html>
  • QuestionService.java 수정
    package com.mysite.sbb.question;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Optional;
import org.springframework.stereotype.Service;
import com.mysite.sbb.DataNotFoundException;
import com.mysite.sbb.user.SiteUser;
import lombok.RequiredArgsConstructor;
@RequiredArgsConstructor
@Service
public class QuestionService {
 private final QuestionRepository questionRepository;   
 public List<Question> getList(){
    return this.questionRepository.findAll();
 }  
 public Question getQuestion(Integer id) {
    Optional<Question> question = this.questionRepository.findById(id);
    if(question.isPresent()) {
       return question.get();
    }else {
       throw new DataNotFoundException("question not found");
    }
 }
 public void create(String subject, String content, SiteUser user) {
    Question q = new Question();
    q.setSubject(subject);
    q.setContent(content);
    q.setCreateDate(LocalDateTime.now());
    q.setAuthor(user);
    this.questionRepository.save(q);
 }
 public void modify(Question question, String subject, String content) {
    question.setSubject(subject);
    question.setContent(content);
    question.setModifyDate(LocalDateTime.now());
    this.questionRepository.save(question);
 }
 public void delete(Question question) {
    this.questionRepository.delete(question);
 }
}
  • QuestionController.java 수정
    package com.mysite.sbb.question;
import java.security.Principal;
import java.util.List;
import org.springframework.http.HttpStatus;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.server.ResponseStatusException;
import com.mysite.sbb.answer.AnswerForm;
import com.mysite.sbb.user.SiteUser;
import com.mysite.sbb.user.UserService;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
@RequestMapping("/question")
@RequiredArgsConstructor
@Controller
public class QuestionController {   
 private final QuestionService questionService;
 private final UserService userService;
 @GetMapping("/list")
 public String list(Model model) {
    List<Question> questionList = this.questionService.getList();
    model.addAttribute("questionList", questionList);
    return "question_list";
 }
 @GetMapping(value = "/detail/{id}")
 public String detail(Model model, @PathVariable("id") Integer id, AnswerForm answerForm) {
    Question question = this.questionService.getQuestion(id);
    model.addAttribute("question",question);
    return "question_detail";
 }   
 @PreAuthorize("isAuthenticated()")
 @GetMapping("/create")
 public String questionCreate(QuestionForm questionForm) {
    return "question_form";
 }   
 @PreAuthorize("isAuthenticated()")// 로그아웃상태에서 호출하면 로그인페이지로 강제 이동.
 @PostMapping("/create")
 public String questionCreate(@Valid QuestionForm questionForm, BindingResult bindingResult, Principal principal ) {
    if(bindingResult.hasErrors()) {
       return "question_form";
    }
    SiteUser siteUser = this.userService.getUser(principal.getName());
    this.questionService.create(questionForm.getSubject(), questionForm.getContent(), siteUser);
    return "redirect:/question/list";   // 질문 저장후 질문 목록으로 이동
 }   
 @PreAuthorize("isAuthenticated()")
 @GetMapping("/modify/{id}")
 public String questionModify(QuestionForm questionForm, @PathVariable("id") Integer id, 
       Principal principal) {
    Question question = this.questionService.getQuestion(id);
    if (!question.getAuthor().getUsername().equals(principal.getName())) {
       throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "수정권한이 없습니다.");
    }
    questionForm.setSubject(question.getSubject());
    questionForm.setContent(question.getContent());
    return "question_form";
 }   
 @PreAuthorize("isAuthenticated()")
 @PostMapping("/modify/{id}")
 public String questionModify(@Valid QuestionForm questionForm, BindingResult bindingResult, Principal principal,
       @PathVariable("id") Integer id) {
    if (bindingResult.hasErrors()) {
       return "question_form";
    }
    Question question = this.questionService.getQuestion(id);
    if (!question.getAuthor().getUsername().equals(principal.getName())) {
       throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "수정권한이 없습니다.");
    }
    this.questionService.modify(question, questionForm.getSubject(), 
          questionForm.getContent());
    return String.format("redirect:/question/detail/%s", id);
 }
 @PreAuthorize("isAuthenticated()")
 @GetMapping("/delete/{id}")
 public String questionDelete(Principal principal, @PathVariable("id") Integer id) {
    Question question = this.questionService.getQuestion(id);
    if (!question.getAuthor().getUsername().equals(principal.getName())) {
       throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "삭제권한이 없습니다.");
    }
    this.questionService.delete(question);
    return "redirect:/";
 }
}
  • question_detail.html 수정
    <html layout:decorate="~{layout}">
<div layout:fragment="content" class="container my-3">
 <!-- 질문-->
 <h2 class="border-bottom py-2" th:text="${question.subject}"></h2> 
 <div class="card my-3">
    <div class="card-body">
       <div class="card-text" style="white-space: pre-line;" th:text="${question.content}"></div>
       <div class="d-flex justify-content-end">
          <div class="badge bg-light text-dark p-2 text-start">
             <div class="mb-2">
                               <span th:if="${question.author != null}"
                               th:text ="${question.author.username}"></span>
                            </div>
              <div th:text="${#temporals.format(question.createDate, 'yyyy-MM-dd HH:mm')}"></div>
          </div>
       </div>
       </div>
       <div class="my-3">                           
          <a th:href="@{|/question/modify/${question.id}|}" class="btn btn-sm btn-outline-secondary"
                sec:authorize="isAuthenticated()" 
                th:if="${question.author != null and #authentication.getPrincipal().getUsername() == question.author.username}" th:text="수정"></a>
          <a href="javascript:void(0);" th:data-uri="@{|/question/delete/${question.id}|}"
                               class="delete btn btn-sm btn-outline-secondary" sec:authorize="isAuthenticated()"
                               th:if="${question.author != null and #authentication.getPrincipal().getUsername() == question.author.username}"
                               th:text="삭제"></a>   
                                     </div>
                </div>      
 <!-- 답변 개수 표시 -->
 <h5 class="border-bottom my-3 py-2" th:text="|${#lists.size(question.answerList)}개의 답변이 있습니다.|"></h5>
 <!-- 답변 반복 시작 -->
 <div class="card my-3" th:each="answer: ${question.answerList}">
    <div class="card-body">
       <div class="card-text" style="white-space:pre-line;" th:text="${answer.content}"></div>
       <div class="d-flex justify-content-end">
          <div class="badge bg-light text-dark p-2 text-start"> 
             <div class="mb-2">
                               <span th:if="${answer.author != null}"
                               th:text ="${answer.author.username}"></span>
                            </div>
             <div th:text="${#temporals.format(answer.createDate, 'yyyy-MM-dd HH:mm')}"></div>      
          </div>
       </div>
       <div class="my-3">
                         <a th:href="@{|/answer/modify/${answer.id}|}" class="btn btn-sm btn-outline-secondary"
                            sec:authorize="isAuthenticated()"
                            th:if="${answer.author != null and #authentication.getPrincipal().getUsername() == answer.author.username}"
                            th:text="수정"></a>
             </div>   
       </div>
    </div>
 <!-- 답변 반복 끝 -->
 <!-- 답변 작성-->
 <form th:action="@{|/answer/create/${question.id}|}" th:object="${answerForm}" method="post" class="my-3">
    <div th:replace="~{form_errors :: formErrorsFragment}"></div>     
    <textarea sec:authorize="isAnonymous()" disabled th:field="*{content}" 
             class="form-control" rows="10"></textarea>
       <textarea sec:authorize="isAuthenticated()" th:field="*{content}" 
          class="form-control" rows="10"></textarea>   
       <input type="submit" value="답변 등록" class="btn btn-primary my-2"> </form>
 </div>
 <script layout:fragment="script" type='text/javascript'>
    const delete_elements = document.getElementsByClassName("delete");
    Array.from(delete_elements).forEach(function (element) {
       element.addEventListener('click', function () {
          if (confirm("정말로 삭제하시겠습니까?")) {
             location.href = this.dataset.uri;
          };
       });
    });
 </script>
 </html>
  • AnswerService.java 수정
    package com.mysite.sbb.answer;
import java.time.LocalDateTime;
import java.util.Optional;
import org.springframework.stereotype.Service;
import com.mysite.sbb.DataNotFoundException;
import com.mysite.sbb.question.Question;
import com.mysite.sbb.user.SiteUser;
import lombok.RequiredArgsConstructor;
@RequiredArgsConstructor
@Service
public class AnswerService {
private final AnswerRepository answerRepository;   
 public void create(Question question, String content, SiteUser author) {
    Answer answer = new Answer();
    answer.setContent(content);
    answer.setCreateDate(LocalDateTime.now());
    answer.setQuestion(question);
    answer.setAuthor(author);
    this.answerRepository.save(answer);
 }
 public Answer getAnswer(Integer id) {
    Optional<Answer> answer = this.answerRepository.findById(id);
    if (answer.isPresent()) {
       return answer.get();
    } else {
       throw new DataNotFoundException("answer not found");
    }
 }
 public void modify(Answer answer, String content) {
    answer.setContent(content);
    answer.setModifyDate(LocalDateTime.now());
    this.answerRepository.save(answer);
 }
}
  • AnswerController.java 수정
    package com.mysite.sbb.answer;
import java.security.Principal;
import org.springframework.http.HttpStatus;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.server.ResponseStatusException;
import com.mysite.sbb.question.Question;
import com.mysite.sbb.question.QuestionService;
import com.mysite.sbb.user.SiteUser;
import com.mysite.sbb.user.UserService;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
@RequestMapping("/answer")
@RequiredArgsConstructor
@Controller
public class AnswerController {
 private final QuestionService questionService;
 private final AnswerService answerService;
 private final UserService userService;   
 @PreAuthorize("isAuthenticated()")
 @PostMapping("/create/{id}")
 public String createAnswer(Model model, @PathVariable("id") Integer id,
       @Valid AnswerForm answerForm, BindingResult bindingResult, Principal principal) {
    Question question = this.questionService.getQuestion(id);
    SiteUser siteUser = this.userService.getUser(principal.getName());
    if(bindingResult.hasErrors()) {
       model.addAttribute("question",question);
       return "question_detail";
    }
    // TODO: 답변을 저장한다.
    this.answerService.create(question, answerForm.getContent(), siteUser);
    return String.format("redirect:/question/detail/%s", id);
 }
 @PreAuthorize("isAuthenticated()")
 @GetMapping("/modify/{id}")
 public String answerModify(AnswerForm answerForm, @PathVariable("id") Integer id, 
       Principal principal) {
    Answer answer = this.answerService.getAnswer(id);
    if (!answer.getAuthor().getUsername().equals(principal.getName())) {
       throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "수정 권한이 없습니다.");
    }
    answerForm.setContent(answer.getContent());
    return "answer_form";
 }
}
  • answer_form.html 생성
    <html layout:decorate="~{layout}">
<div layout:fragment="content" class="container">
 <h5 class="my-3 border-bottom pb-2">답변 수정</h5>
 <form th:object="${answerForm}" method="post">
    <input type="hidden" th:name="${_csrf.parameterName}" th:value="${_csrf.token}" />
    <div th:replace="~{form_errors :: formErrorsFragment}"></div>
    <div class="mb-3">
       <label for="content" class="form-label">내용</label>
       <textarea th:field="*{content}" class="form-control" rows="10"></textarea>
    </div>
    <input type="submit" value="저장하기" class="btn btn-primary my-2">
 </form>
</div>
</html>
  • AnswerController.java 수정
    package com.mysite.sbb.answer;
import java.security.Principal;
import org.springframework.http.HttpStatus;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.server.ResponseStatusException;
import com.mysite.sbb.question.Question;
import com.mysite.sbb.question.QuestionService;
import com.mysite.sbb.user.SiteUser;
import com.mysite.sbb.user.UserService;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
@RequestMapping("/answer")
@RequiredArgsConstructor
@Controller
public class AnswerController {
 private final QuestionService questionService;
 private final AnswerService answerService;
 private final UserService userService;
 @PreAuthorize("isAuthenticated()")
 @PostMapping("/create/{id}")
 public String createAnswer(Model model, @PathVariable("id") Integer id,
       @Valid AnswerForm answerForm, BindingResult bindingResult, Principal principal) {
    Question question = this.questionService.getQuestion(id);
    SiteUser siteUser = this.userService.getUser(principal.getName());
    if(bindingResult.hasErrors()) {
       model.addAttribute("question",question);
       return "question_detail";
    }
    // TODO: 답변을 저장한다.
    this.answerService.create(question, answerForm.getContent(), siteUser);
    return String.format("redirect:/question/detail/%s", id);
 }
 @PreAuthorize("isAuthenticated()")
 @GetMapping("/modify/{id}")
 public String answerModify(AnswerForm answerForm, @PathVariable("id") Integer id, 
       Principal principal) {
    Answer answer = this.answerService.getAnswer(id);
    if (!answer.getAuthor().getUsername().equals(principal.getName())) {
       throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "수정 권한이 없습니다.");
    }
    answerForm.setContent(answer.getContent());
    return "answer_form";
 }
 @PreAuthorize("isAuthenticated()")
 @PostMapping("/modify/{id}")
 public String answerModify(@Valid AnswerForm answerForm, BindingResult bindingResult,
       @PathVariable("id") Integer id, Principal principal) {
    if (bindingResult.hasErrors()) {
       return "answer_form";
    }
    Answer answer = this.answerService.getAnswer(id);
    if (!answer.getAuthor().getUsername().equals(principal.getName())) {
       throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "수정 권한이 없습니다.");
    }
    this.answerService.modify(answer, answerForm.getContent());
    return String.format("redirect:/question/detail/%s#answer_%s", 
          answer.getQuestion().getId(), answer.getId());
 }
}
  • question_detail.html 수정
    <html layout:decorate="~{layout}">
<div layout:fragment="content" class="container my-3">
 <!-- 질문-->
 <h2 class="border-bottom py-2" th:text="${question.subject}"></h2> 
 <div class="card my-3">
    <div class="card-body">
       <div class="card-text" style="white-space: pre-line;" th:text="${question.content}"></div>
       <div class="d-flex justify-content-end">
          <div class="badge bg-light text-dark p-2 text-start">
             <div class="mb-2">
                               <span th:if="${question.author != null}"
                               th:text ="${question.author.username}"></span>
                            </div>
              <div th:text="${#temporals.format(question.createDate, 'yyyy-MM-dd HH:mm')}"></div>
          </div>
       </div>
       </div>
       <div class="my-3">                           
          <a th:href="@{|/question/modify/${question.id}|}" class="btn btn-sm btn-outline-secondary"
                sec:authorize="isAuthenticated()" 
                th:if="${question.author != null and #authentication.getPrincipal().getUsername() == question.author.username}" th:text="수정"></a>
          <a href="javascript:void(0);" th:data-uri="@{|/question/delete/${question.id}|}"
                               class="delete btn btn-sm btn-outline-secondary" sec:authorize="isAuthenticated()"
                               th:if="${question.author != null and #authentication.getPrincipal().getUsername() == question.author.username}"
                               th:text="삭제"></a>   
                                     </div>
                </div>   
 <!-- 답변 개수 표시 -->
 <h5 class="border-bottom my-3 py-2" th:text="|${#lists.size(question.answerList)}개의 답변이 있습니다.|"></h5>
 <!-- 답변 반복 시작 -->
 <div class="card my-3" th:each="answer: ${question.answerList}">
    <div class="card-body">
       <div class="card-text" style="white-space:pre-line;" th:text="${answer.content}"></div>
       <div class="d-flex justify-content-end">
          <div class="badge bg-light text-dark p-2 text-start"> 
             <div class="mb-2">
                               <span th:if="${answer.author != null}"
                               th:text ="${answer.author.username}"></span>
                            </div>
             <div th:text="${#temporals.format(answer.createDate, 'yyyy-MM-dd HH:mm')}"></div>      
          </div>
       </div>
       <div class="my-3">
                         <a th:href="@{|/answer/modify/${answer.id}|}" class="btn btn-sm btn-outline-secondary"
                            sec:authorize="isAuthenticated()"
                            th:if="${answer.author != null and #authentication.getPrincipal().getUsername() == answer.author.username}"
                            th:text="수정"></a>
                            <a href="javascript:void(0);" th:data-uri="@{|/answer/delete/${answer.id}|}"
                                                 class="delete btn btn-sm btn-outline-secondary" sec:authorize="isAuthenticated()"
                                                 th:if="${answer.author != null and #authentication.getPrincipal().getUsername() == answer.author.username}"
                                                 th:text="삭제"></a>
             </div>   
       </div>
    </div>
 <!-- 답변 반복 끝 -->
 <!-- 답변 작성-->
 <form th:action="@{|/answer/create/${question.id}|}" th:object="${answerForm}" method="post" class="my-3">
    <div th:replace="~{form_errors :: formErrorsFragment}"></div>      
    <textarea sec:authorize="isAnonymous()" disabled th:field="*{content}" 
             class="form-control" rows="10"></textarea>
       <textarea sec:authorize="isAuthenticated()" th:field="*{content}" 
          class="form-control" rows="10"></textarea>            
       <input type="submit" value="답변 등록" class="btn btn-primary my-2"> </form>
 </div>   
 <script layout:fragment="script" type='text/javascript'>
    const delete_elements = document.getElementsByClassName("delete");
    Array.from(delete_elements).forEach(function (element) {
       element.addEventListener('click', function () {
          if (confirm("정말로 삭제하시겠습니까?")) {
             location.href = this.dataset.uri;
          };
       });
    });
 </script>
 </html>
  • AnswerService.java 수정
    package com.mysite.sbb.answer;
import java.time.LocalDateTime;
import java.util.Optional;
import org.springframework.stereotype.Service;
import com.mysite.sbb.DataNotFoundException;
import com.mysite.sbb.question.Question;
import com.mysite.sbb.user.SiteUser;
import lombok.RequiredArgsConstructor;
@RequiredArgsConstructor
@Service
public class AnswerService {
 private final AnswerRepository answerRepository;   
 public void create(Question question, String content, SiteUser author) {
    Answer answer = new Answer();
    answer.setContent(content);
    answer.setCreateDate(LocalDateTime.now());
    answer.setQuestion(question);
    answer.setAuthor(author);
    this.answerRepository.save(answer);
 }
 public Answer getAnswer(Integer id) {
    Optional<Answer> answer = this.answerRepository.findById(id);
    if (answer.isPresent()) {
       return answer.get();
    } else {
       throw new DataNotFoundException("answer not found");
    }
 }
 public void modify(Answer answer, String content) {
    answer.setContent(content);
    answer.setModifyDate(LocalDateTime.now());
    this.answerRepository.save(answer);
 }
 public void delete(Answer answer) {
    this.answerRepository.delete(answer);
 }
}
  • AnswerController.java 수정
    package com.mysite.sbb.answer;
import java.security.Principal;
import org.springframework.http.HttpStatus;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.server.ResponseStatusException;
import com.mysite.sbb.question.Question;
import com.mysite.sbb.question.QuestionService;
import com.mysite.sbb.user.SiteUser;
import com.mysite.sbb.user.UserService;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
@RequestMapping("/answer")
@RequiredArgsConstructor
@Controller
public class AnswerController {
 private final QuestionService questionService;
 private final AnswerService answerService;
 private final UserService userService;   
 @PreAuthorize("isAuthenticated()")
 @PostMapping("/create/{id}")
 public String createAnswer(Model model, @PathVariable("id") Integer id,
       @Valid AnswerForm answerForm, BindingResult bindingResult, Principal principal) {
    Question question = this.questionService.getQuestion(id);
    SiteUser siteUser = this.userService.getUser(principal.getName());
    if(bindingResult.hasErrors()) {
       model.addAttribute("question",question);
       return "question_detail";
    }
    // TODO: 답변을 저장한다.
    this.answerService.create(question, answerForm.getContent(), siteUser);
    return String.format("redirect:/question/detail/%s", id);
 }
 @PreAuthorize("isAuthenticated()")
 @GetMapping("/modify/{id}")
 public String answerModify(AnswerForm answerForm, @PathVariable("id") Integer id, 
       Principal principal) {
    Answer answer = this.answerService.getAnswer(id);
    if (!answer.getAuthor().getUsername().equals(principal.getName())) {
       throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "수정 권한이 없습니다.");
    }
    answerForm.setContent(answer.getContent());
    return "answer_form";
 }   
 @PreAuthorize("isAuthenticated()")
 @PostMapping("/modify/{id}")
 public String answerModify(@Valid AnswerForm answerForm, BindingResult bindingResult,
       @PathVariable("id") Integer id, Principal principal) {
    if (bindingResult.hasErrors()) {
       return "answer_form";
    }
    Answer answer = this.answerService.getAnswer(id);
    if (!answer.getAuthor().getUsername().equals(principal.getName())) {
       throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "수정 권한이 없습니다.");
    }
    this.answerService.modify(answer, answerForm.getContent());
    return String.format("redirect:/question/detail/%s#answer_%s", 
          answer.getQuestion().getId(), answer.getId());
 }  
 @PreAuthorize("isAuthenticated()")
 @GetMapping("/delete/{id}")
 public String answerDelete(Principal principal, @PathVariable("id") Integer id) {
    Answer answer = this.answerService.getAnswer(id);
    if (!answer.getAuthor().getUsername().equals(principal.getName())) {
       throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "삭제권한이 없습니다.");
    }
    this.answerService.delete(answer);
    return String.format("redirect:/question/detail/%s", answer.getQuestion().getId());
 }
}
  • 실행 및 결과
  • question_detail.html 수정
    <html layout:decorate="~{layout}">
<div layout:fragment="content" class="container my-3">
 <!-- 질문-->
 <h2 class="border-bottom py-2" th:text="${question.subject}"></h2> 
 <div class="card my-3">
    <div class="card-body">
       <div class="card-text" style="white-space: pre-line;" th:text="${question.content}"></div>
       <div class="d-flex justify-content-end">
          <div th:if="${question.modifyDate != null}" class="badge bg-light text-dark p-2 text-start mx-3">
                                  <div class="mb-2">modified at</div>
                                  <div th:text="${#temporals.format(question.modifyDate, 'yyyy-MM-dd HH:mm')}"></div>
                               </div>
          <div class="badge bg-light text-dark p-2 text-start">
             <div class="mb-2">
                               <span th:if="${question.author != null}"
                               th:text ="${question.author.username}"></span>
                            </div>
              <div th:text="${#temporals.format(question.createDate, 'yyyy-MM-dd HH:mm')}"></div>
          </div>
       </div>
       </div>
       <div class="my-3">                           
          <a th:href="@{|/question/modify/${question.id}|}" class="btn btn-sm btn-outline-secondary"
                sec:authorize="isAuthenticated()" 
                th:if="${question.author != null and #authentication.getPrincipal().getUsername() == question.author.username}" th:text="수정"></a>
          <a href="javascript:void(0);" th:data-uri="@{|/question/delete/${question.id}|}"
                               class="delete btn btn-sm btn-outline-secondary" sec:authorize="isAuthenticated()"
                               th:if="${question.author != null and #authentication.getPrincipal().getUsername() == question.author.username}"
                               th:text="삭제"></a>   
                                     </div>
                </div>      
 <!-- 답변 개수 표시 -->
 <h5 class="border-bottom my-3 py-2" th:text="|${#lists.size(question.answerList)}개의 답변이 있습니다.|"></h5>
 <!-- 답변 반복 시작 -->
 <div class="card my-3" th:each="answer: ${question.answerList}">
    <div class="card-body">
       <div class="card-text" style="white-space:pre-line;" th:text="${answer.content}"></div>
       <div class="d-flex justify-content-end">
          <div th:if="${answer.modifyDate != null}" class="badge bg-light text-dark p-2 text-start mx-3">
                                  <div class="mb-2">modified at</div>
                                  <div th:text="${#temporals.format(answer.modifyDate, 'yyyy-MM-dd HH:mm')}"></div>
                               </div>
          <div class="badge bg-light text-dark p-2 text-start"> 
             <div class="mb-2">
                               <span th:if="${answer.author != null}"
                               th:text ="${answer.author.username}"></span>
                            </div>
             <div th:text="${#temporals.format(answer.createDate, 'yyyy-MM-dd HH:mm')}"></div>
          </div>
       </div>
       <div class="my-3">
                         <a th:href="@{|/answer/modify/${answer.id}|}" class="btn btn-sm btn-outline-secondary"
                            sec:authorize="isAuthenticated()"
                            th:if="${answer.author != null and #authentication.getPrincipal().getUsername() == answer.author.username}"
                            th:text="수정"></a>
                            <a href="javascript:void(0);" th:data-uri="@{|/answer/delete/${answer.id}|}"
                                                 class="delete btn btn-sm btn-outline-secondary" sec:authorize="isAuthenticated()"
                                                 th:if="${answer.author != null and #authentication.getPrincipal().getUsername() == answer.author.username}"
                                                 th:text="삭제"></a>
             </div>   
       </div>
    </div>
 <!-- 답변 반복 끝 -->
 <!-- 답변 작성-->
 <form th:action="@{|/answer/create/${question.id}|}" th:object="${answerForm}" method="post" class="my-3">
    <div th:replace="~{form_errors :: formErrorsFragment}"></div>      
    <textarea sec:authorize="isAnonymous()" disabled th:field="*{content}" 
             class="form-control" rows="10"></textarea>
       <textarea sec:authorize="isAuthenticated()" th:field="*{content}" 
          class="form-control" rows="10"></textarea>            
       <input type="submit" value="답변 등록" class="btn btn-primary my-2"> </form>
 </div>   
 <script layout:fragment="script" type='text/javascript'>
    const delete_elements = document.getElementsByClassName("delete");
    Array.from(delete_elements).forEach(function (element) {
       element.addEventListener('click', function () {
          if (confirm("정말로 삭제하시겠습니까?")) {
             location.href = this.dataset.uri;
          };
       });
    });
 </script>
 </html>
  • 실행 및 결과 (수정시간이 나옴)

파일 내보내는 방법

]]> <![CDATA[SpringBoot - 게시판 질문과 답변]]> https://velog.io/@hi_do/SpringBoot- https://velog.io/@hi_do/SpringBoot- Tue, 18 Jun 2024 03:09:36 GMT 질문 목록 만들기
  • QuestionController.java 수정
    package com.mysite.sbb.question;
import java.util.List;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import lombok.RequiredArgsConstructor;
@RequiredArgsConstructor
@Controller
public class QuestionController {
 private final QuestionRepository questionRepository;
 @GetMapping("/question/list")
 public String list(Model model) {
    List<Question> questionList = this.questionRepository.findAll();
    model.addAttribute("questionList", questionList);
    return "question_list";
 }
}
  • templates 에 question_list.html 생성
    <tr th:each="question : ${questionList}">
    <td th:text="${question.subject}"></td>
    <td th:text="${question.createDate}"></td>
</tr>
<tr th:each="question : ${questionList}">
 <td>[[$question.subject]]]</td>
 <td>[[$question.createDate]]]</td>
</td>

  • th : text 속성 대신에 대괄호를 사용하여 값을 직접 출력할 수 있다

    Service(서비스)

  • 대부분의 규모 있는 부트 프로젝트는 컨트롤러에서 라포지터리를 직접 호출하지 않고 중간에 서비스를 두어 데이터를 처리

    서비스가 필요한 이유

  • 복잡한 코드를 모듈화하는 것 A,B 컨트롤러가 중복된 코드를 각 호출하느 것보다 Service에 중복된 기능을 넣어 놓고 A,B가 Service를 호출하게 만든다

    DTO(Data Transfer Object)

  • entity 객체를 DTO객체로 변환해야 한다 Question, Answer 엔티티 클래스는 데이터 베이스와 직접 맞닿아 있는 클래스 컨트롤러 또는 타임리프와 같은 템플릿 엔진에 전달해 직접적으로 사용하는 것은 좋지 않다

  • 왜냐하면 엔티티 객체는 민감한 데이터가 포함될 수 있는데 타임리프에서 엔티티 객체를 직접 사용하면 민감한 데이터가 노출될 위험이 있기 때문이다. Question, Answer같은 엔티티 클래스는 컨트롤러에서 사용하지 않도록 설계하는 것이 좋다. 얘네를 대신해서 DTO를 사용한다.

  • 엔티티객체를 DTO객체로 변환하려면??? 이때도 서비스가 필요하다.

  • 서비스는 컨트롤러와 리포지터리의 중간에서 엔티티 객체와 DTO객체를 서로 변환하여 양방향에 전달하는 역할을 한다.

  • QuestionService.java 생성
    package com.mysite.sbb.question;
import java.util.List;
import org.springframework.stereotype.Service;
import lombok.RequiredArgsConstructor;
@RequiredArgsConstructor
@Service
public class QuestionService {    
  private final QuestionRepository questionRepository;
  public List<Question> getList() {
      return this.questionRepository.findAll();
  }
}
  • QuestionController.java 수정
    package com.mysite.sbb.question;
import java.util.List;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import lombok.RequiredArgsConstructor;
@RequiredArgsConstructor
@Controller
public class QuestionController {   
 private final QuestionService questionservice;   
 @GetMapping("/question/list")
 public String list(Model model) {
    List<Question> questionList = this.questionservice.getList();
    model.addAttribute("questionList", questionList);
    return "question_list";
 }
}
  • 다른 컨트롤러들도 이러한 순서로 접근하여 데이터를 처리한다. Controller -> service -> repository
  • QuestionList.html 수정
    <table>
 <thead>
    <tr>
       <th>제목</th>
       <th>작성일시</th>
    </tr>
 </thead>
 <tbody>
    <tr th:each="question : ${questionList}">
       <td>
          <a th:href="@{|/question/detail/${question.id}|}"
          th:text="${question.subject}"></a>
       </td> 
       <td th:text="${question.createDate}"></td>
    </tr>
 </tbody>
</table>
    <a th:href="@{|/question/detail/${question.id}|}"

  • URL 연결할때 타임리프에서 th:href 속성을 사용한다. 이때, URL은 반드시@{와} 문자 사이에 입력해야 한다. '|'를 앞뒤로 감싸는 경우는 변수와 텍스트의 조합일 경우에 감싼다. /question/list 와 같은 문자열과 ${question.id}는 자바객체의 값을 같이 사용할때는 반드시 '|'를 좌우로 감싸준다.

  • QuestionController.java 수정
    package com.mysite.sbb.question;
import java.util.List;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import lombok.RequiredArgsConstructor;
@RequiredArgsConstructor
@Controller
public class QuestionController {  
 private final QuestionService questionService;  
 @GetMapping("/question/list")
 public String list(Model model) {
    List<Question> questionList = this.questionService.getList();
    model.addAttribute("questionList", questionList);
    return "question_list";
 }
 @GetMapping(value = "/question/detail/{id}")
 public String detail(Model model, @PathVariable("id") Integer id) {
    return "question_detail";
 }
}
  • 둘 다 데이터를 받아오기 위한 쿼리스트링, 파라미터 처리 @PathVariable : 파라미터값으로 하나만 받아올 수 있다. @RequestParam : 쿼리스트링 같은 여러개의 데이터를 받아올때 사용 (key-value 형태로 받아올 수 있다)
  • QuestionService.java 수정
    package com.mysite.sbb.question;
import java.util.List;
import java.util.Optional;
import org.springframework.stereotype.Service;
import com.mysite.sbb.DataNotFoundException;
import lombok.RequiredArgsConstructor;
@RequiredArgsConstructor
@Service
public class QuestionService {    
  private final QuestionRepository questionRepository;    
  public List<Question> getList() {
      return this.questionRepository.findAll();
  }    
  public Question getQuestion(Integer id) {
      Optional<Question> question = this.questionRepository.findById(id);
      if(question.isPresent()) {
          return question.get();
      }else {
          throw new DataNotFoundException("question not found");
      }
  }
}
  • DataNotFoundException.java 생성
    package com.mysite.sbb;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ResponseStatus;
@ResponseStatus(value = HttpStatus.NOT_FOUND, reason = "entity not found")
public class DataNotFoundException extends RuntimeException{
// RuntimeException: 실행시 발생하는 예외
  private static final long serialVersionUID = 1L;
  public DataNotFoundException(String message) {
      super(message);
  }
}
  • QuestionController.java 수정
    package com.mysite.sbb.question;
import java.util.List;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import lombok.RequiredArgsConstructor;
@RequiredArgsConstructor
@Controller
public class QuestionController {   
 private final QuestionService questionService;
 @GetMapping("/question/list")
 public String list(Model model) {
    List<Question> questionList = this.questionService.getList();
    model.addAttribute("questionList", questionList);
    return "question_list";
 }
 @GetMapping(value = "/question/detail/{id}")
 public String detail(Model model, @PathVariable("id") Integer id) {
     Question question = this.questionService.getQuestion(id);
     model.addAttribute("question",question);
    return "question_detail";
 }
}

  • DataNotFoundException.javad의 @ResponseStatus(value = HttpStatus.NOT_FOUND, reason = "entity not found") QuestionService.javad 의 throw new DataNotFoundException("question not found"); 가 실행됨

  • 클릭시 로 이동

  • QuestionController.java 수정
    package com.mysite.sbb.question;
import java.util.List;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import lombok.RequiredArgsConstructor;
@RequestMapping("/question")
@RequiredArgsConstructor
@Controller
public class QuestionController {  
 private final QuestionService questionService;   
 @GetMapping("/list")
 public String list(Model model) {
    List<Question> questionList = this.questionService.getList();
    model.addAttribute("questionList", questionList);
    return "question_list";
 }
 @GetMapping(value = "/detail/{id}")
 public String detail(Model model, @PathVariable("id") Integer id) {
     Question question = this.questionService.getQuestion(id);
     model.addAttribute("question",question);
    return "question_detail";
 }
}
  • question_detail.html 생성
    <h1 th:text="${question.subject}"></h1>
<div th:text="${question.content}"></div>
<form th:action="@{|/answer/create/${question.id}|}" method="post">
 <textarea name="content" id="content" rows="15"></textarea>
 <input type="submit" value="답변 등록 ">
</form>
  • 실행 및 결과
  • AnswerController.java 생성
    package com.mysite.sbb.answer;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import com.mysite.sbb.question.Question;
import com.mysite.sbb.question.QuestionService;
import lombok.RequiredArgsConstructor;
@RequestMapping("/answer")
@RequiredArgsConstructor
@Controller
public class AnswerController {
 private final QuestionService questionService;   
 @PostMapping("/create/{id}")
 public String createAnswer(Model model, @PathVariable("id") Integer id, 
       @RequestParam(value="content") String content) {
    Question question = this.questionService.getQuestion(id);
    // TODO: 답변을 저장한다.
    return String.format("redirect:/questiohn/detail/%s", id);
 }
}
  • AnswerService.java 생성
    package com.mysite.sbb.answer;
import java.time.LocalDateTime;
import org.springframework.stereotype.Service;
import com.mysite.sbb.question.Question;
import lombok.RequiredArgsConstructor;
@RequiredArgsConstructor
@Service
public class AnswerService {
  private final AnswerRepository answerRepository;
  public void create(Question question, String content) {
      Answer answer = new Answer();
      answer.setContent(content);
      answer.setCreateDate(LocalDateTime.now());
      answer.setQuestion(question);
      this.answerRepository.save(answer);
  }
}
  • AnswerController.java 수정
    package com.mysite.sbb.answer;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import com.mysite.sbb.question.Question;
import com.mysite.sbb.question.QuestionService;
import lombok.RequiredArgsConstructor;
@RequestMapping("/answer")
@RequiredArgsConstructor
@Controller
public class AnswerController {
 private final QuestionService questionService;
 private final AnswerService answerService;   
 @PostMapping("/create/{id}")
 public String createAnswer(Model model, @PathVariable("id") Integer id, 
       @RequestParam(value="content") String content) {
    Question question = this.questionService.getQuestion(id);
    // TODO: 답변을 저장한다.
    this.answerService.create(question, content);
    return String.format("redirect:/questiohn/detail/%s", id);
 }
}
  • question_detail.html 수정 ````html

    // th : thymeleaf //# : thymeleaf의 내장함수 // #의 의미 : thymeleaf 가 lists 내장 객체를 가지고 있고 lists 가 size 하는 내장 메서드를 가지고 있다.
    ```
  • 실행 및 결과

static에 style.css 생성

textarea{
   width: 100%;
}
input[type=submit]{
   margin-top: 10px;
}
  • css 다운받는곳 : https://getbootstrap.com/docs/5.3/getting-started/download/
  • 압축 푼 후 bootstrap.min.css 복사 static에 붙여넣기
  • question_detail.html 수정
    <link rel="stylesheet" type="text/css" th:href="@{/style.css}">
<h1 th:text="${question.subject}"></h1>
<div th:text="${question.content}"></div>
<h5 th:text="|${#lists.size(question.answerList)}개의 답변이 있습니다.|"></h5>
<div>
 <ul>
    <li th:each="answer : ${question.answerList}" th:text="${answer.content}"></li>
 </ul>
</div>
<form th:action="@{|/answer/create/${question.id}|}" method="post">
 <textarea name="content" id="content" rows="15"></textarea>
 <input type="submit" value="답변 등록 ">
</form>
  • question_list.html 수정
    <link rel="stylesheet" type="text/css" th:href="@{/bootstrap.min.css}">
<div class="container my-3">
<table class="table">
 <thead class="table-dark">
    <tr>
       <th>번호</th>
       <th>제목</th>
       <th>작성일시</th>
    </tr>
 </thead>
 <tbody>
    <tr th:each="question, loop : ${questionList}">
       <td th:text="${loop.count}"></td>
       <td>
          <a th:href="@{|/question/detail/${question.id}|}"
          th:text="${question.subject}"></a>
       </td> 
       <td th:text="${#temporals.format(question.createDate,'yyyy-MM-dd HH:mm')}"></td>
    </tr>
 </tbody>
</table>
</div>
  • question_detail.html 수정
    <link rel="stylesheet" type="text/css" th:href="@{/bootstrap.min.css}">
<div class="container my-3">
 <!-- 질문-->
 <h2 class="border-bottom py-2" th:text="${question.subject}"></h2> 
 <div class="card my-3">
    <div class="card-body">
       <div class="card-text" style="white-space: pre-line;" th:text="${question.content}"></div>
       <div class="d-flex justify-content-end">
          <div class="badge bg-light text-dark p-2 text-start">
              <div th:text="${#temporals.format(question.createDate, 'yyyy-MM-dd HH:mm')}"></div>
          </div>
       </div>
       </div>
    </div>
 <!-- 답변 개수 표시 -->
 <h5 class="border-bottom my-3 py-2" th:text="|${#lists.size(question.answerList)}개의 답변이 있습니다.|"></h5>
 <!-- 답변 반복 시작 -->
 <div class="card my-3" th:each="answer: ${question.answerList}">
    <div class="card-body">
       <div class="card-text" style="white-space:pre-line;" th:text="${answer.content}"></div>
       <div class="d-flex justify-content-end">
          <div class="badge bg-light text-dark p-2 text-start"> 
             <div th:text="${#temporals.format(answer.createDate, 'yyyy-MM-dd HH:mm')}"></div>      
          </div>
       </div>
       </div>
    </div>
 <!-- 답변 반복 끝 -->
 <!-- 답변 작성-->
 <form th:action="@{|/answer/create/${question.id}|}" method="post" class="my-3">
    <textarea name="content" id="content" rows="10" class="form-control"></textarea>
    <input type="submit" value="답변 등록" class="btn btn-primary my-2"> </form>
</div>
    <html layout:decorate="~{layout}">
  • question_list 수정
    <html layout:decorate="~{layout}">
<div layout:fragment="content" class="container my-3">
<table class="table">
 <thead class="table-dark">
    <tr>
       <th>번호</th>
       <th>제목</th>
       <th>작성일시</th>
    </tr>
 </thead>
 <tbody>
    <tr th:each="question, loop : ${questionList}">
       <td th:text="${loop.count}"></td>
       <td>
          <a th:href="@{|/question/detail/${question.id}|}"
          th:text="${question.subject}"></a>
       </td> 
       <td th:text="${#temporals.format(question.createDate,'yyyy-MM-dd HH:mm')}"></td>
    </tr>
 </tbody>
</table>
</div>
    • layout.html 생성
      <!doctype html>
<html lang="ko">
<head>
<!-- Required meta tags -->
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
<!-- Bootstrap CSS -->
<link rel="stylesheet" type="text/css" th:href="@{/bootstrap.min.css}">
<!-- sbb CSS -->
<link rel="stylesheet" type="text/css" th:href="@{/style.css}">
<title>Hello, sbb!</title>
</head>
<body>
<!-- 기본 템플릿 안에 삽입될 내용 Start -->
<th:block layout:fragment="content"></th:block>
<!-- 기본 템플릿 안에 삽입될 내용 End -->
</body>
</html>

  • 현재 페이지에 레이웃 템플릿을 적용(여기에서는 layout.html) ~{} 구문은 thymeleaf에서 템플릿 경로를 나타낸다

  • 부모 템플릿은 layout.html인
     <!-- 기본 템플릿 안에 삽입될 내용 Start -->
 <th:block layout:fragment="content"></th:block>
 <!-- 기본 템플릿 안에 삽입될 내용 End -->
-> 부모 템플릿에 작성된 부분를 자식 템플릿의 내용으로 적용될 수 있도록
<div layout.fragment="content" class="container my-3">
  ..생략
</div>
    • question_detail.html 수정
      <html layout:decorate="~{layout}">
<div layout:fragment="content" class="container my-3">
<!-- 질문-->
<h2 class="border-bottom py-2" th:text="${question.subject}"></h2> 
<div class="card my-3">
  <div class="card-body">
     <div class="card-text" style="white-space: pre-line;" th:text="${question.content}"></div>
     <div class="d-flex justify-content-end">
        <div class="badge bg-light text-dark p-2 text-start">
            <div th:text="${#temporals.format(question.createDate, 'yyyy-MM-dd HH:mm')}"></div>
        </div>
     </div>
     </div>
  </div>
<!-- 답변 개수 표시 -->
<h5 class="border-bottom my-3 py-2" th:text="|${#lists.size(question.answerList)}개의 답변이 있습니다.|"></h5>
<!-- 답변 반복 시작 -->
<div class="card my-3" th:each="answer: ${question.answerList}">
  <div class="card-body">
     <div class="card-text" style="white-space:pre-line;" th:text="${answer.content}"></div>
     <div class="d-flex justify-content-end">
        <div class="badge bg-light text-dark p-2 text-start"> 
           <div th:text="${#temporals.format(answer.createDate, 'yyyy-MM-dd HH:mm')}"></div>      
        </div>
     </div>
     </div>
  </div>
<!-- 답변 반복 끝 -->
<!-- 답변 작성-->
<form th:action="@{|/answer/create/${question.id}|}" method="post" class="my-3">
  <textarea name="content" id="content" rows="10" class="form-control"></textarea>
  <input type="submit" value="답변 등록" class="btn btn-primary my-2"> </form>
</div>
</html>
    • question_list.html 수정
      <html layout:decorate="~{layout}">
<div layout:fragment="content" class="container my-3">
<table class="table">
<thead class="table-dark">
  <tr>
     <th>번호</th>
     <th>제목</th>
     <th>작성일시</th>
  </tr>
</thead>
<tbody>
  <tr th:each="question, loop : ${questionList}">
     <td th:text="${loop.count}"></td>
     <td>
        <a th:href="@{|/question/detail/${question.id}|}"
        th:text="${question.subject}"></a>
     </td> 
     <td th:text="${#temporals.format(question.createDate,'yyyy-MM-dd HH:mm')}"></td>
  </tr>
</tbody>
</table>
<a th:href="@{/question/create}" class = "btn btn-primary">질문 등록하기</a>
</div>
</html>
    • QuestionController.java 수정
      package com.mysite.sbb.question;
import java.util.List;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import lombok.RequiredArgsConstructor;
@RequestMapping("/question")
@RequiredArgsConstructor
@Controller
public class QuestionController {  
private final QuestionService questionService;
@GetMapping("/list")
public String list(Model model) {
  List<Question> questionList = this.questionService.getList();
  model.addAttribute("questionList", questionList);
  return "question_list";
}
@GetMapping(value = "/detail/{id}")
public String detail(Model model, @PathVariable("id") Integer id) {
   Question question = this.questionService.getQuestion(id);
   model.addAttribute("question",question);
  return "question_detail";
}
@GetMapping("/create")
public String questionCreate() {
   return "question_form";
}
}
  • question_form.html 생성
    <html layout:decorate="~{layout}">
<div layout:fragment="content" class="container">
 <h5 class="my-3 border-bottom pb-2">질문등록</h5>
 <form th:action="@{/question/create}" method="post">
    <div class="mb-3">
       <label for="subject" class="form-label">제목</label>
       <input type="text" name="subject" id="subject" class="form-control">
    </div>
    <div class="mb-3">
       <label for="content" class="form-label">내용</label>
       <textarea name="content" id="content" class="form-control" rows="10"></textarea>
    </div>
    <input type="submit" value="저장하기" class="btn btn-primary my-2">
 </form>
</div>
</html>
  • QuestionController.java 수정
    package com.mysite.sbb.question;
import java.util.List;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import lombok.RequiredArgsConstructor;
@RequestMapping("/question")
@RequiredArgsConstructor
@Controller
public class QuestionController {  
 private final QuestionService questionService;   
 @GetMapping("/list")
 public String list(Model model) {
    List<Question> questionList = this.questionService.getList();
    model.addAttribute("questionList", questionList);
    return "question_list";
 }
 @GetMapping(value = "/detail/{id}")
 public String detail(Model model, @PathVariable("id") Integer id) {
     Question question = this.questionService.getQuestion(id);
     model.addAttribute("question",question);
    return "question_detail";
 }
 @GetMapping("/create")
 public String questionCreate() {
     return "question_form";
 }
 @PostMapping("/create")
 public String questionCreate(@RequestParam(value="subject") String subject,
         @RequestParam(value="content") String content) {
     //TODO: 질문을 저장한다.
     this.questionService.create(subject, content);
     return "redirect:/question/list";    // 질문 저장 후 질문 목록으로 이동
 }
}
  • QuestionService.java 수정
    package com.mysite.sbb.question;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Optional;
import org.springframework.stereotype.Service;
import com.mysite.sbb.DataNotFoundException;
import lombok.RequiredArgsConstructor;
@RequiredArgsConstructor
@Service
public class QuestionService {
 private final QuestionRepository questionRepository;  
 public List<Question> getList(){
    return this.questionRepository.findAll();
 }
 public Question getQuestion(Integer id) {
    Optional<Question> question = this.questionRepository.findById(id);
    if(question.isPresent()) {
       return question.get();
    }else {
       throw new DataNotFoundException("question not found");
    }
 }
 public void create(String subject, String content) {
    Question q = new Question();
    q.setSubject(subject);
    q.setContent(content);
    q.setCreateDate(LocalDateTime.now());
    this.questionRepository.save(q);
 }
}
  • build.gradle에 
    implementation 'org.springframework.boot:spring-boot-starter-validation'
    추가 후 refresh
  • QuestionController.java 수정
    package com.mysite.sbb.question;
import java.util.List;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
@RequestMapping("/question")
@RequiredArgsConstructor
@Controller
public class QuestionController {
 private final QuestionService questionService;   
 @GetMapping("/list")
 public String list(Model model) {
    List<Question> questionList = this.questionService.getList();
    model.addAttribute("questionList", questionList);
    return "question_list";
 }   
 @GetMapping(value = "/detail/{id}")
 public String detail(Model model, @PathVariable("id") Integer id) {
    Question question = this.questionService.getQuestion(id);
    model.addAttribute("question",question);
    return "question_detail";
 }
 @GetMapping("/create")
 public String questionCreate() {
    return "question_form";
 }
 @PostMapping("/create")
 public String questionCreate(@Valid QuestionForm questionForm, BindingResult bindingResult) {
    if(bindingResult.hasErrors()) {
       return "question_form";
    }
    this.questionService.create(questionForm.getSubject(), questionForm.getContent());
    return "redirect:/question/list";   // 질문 저장후 질문 목록으로 이동
 }
}
  • question_form.html 수정
    <html layout:decorate="~{layout}">
<div layout:fragment="content" class="container">
 <h5 class="my-3 border-bottom pb-2">질문등록</h5>
 <form th:action="@{/question/create}" th:object="${questionForm}" method="post">
       <div class="alert alert-danger" role="alert" th:if="${#fields.hasAnyErrors()}">
          <div th:each="err : ${#fields.allErrors()}" th:text="${err}" />
       </div>
    <div class="mb-3">
       <label for="content" class="form-label">내용</label>
       <textarea name="content" id="content" class="form-control" rows="10"></textarea>
    </div>
    <input type="submit" value="저장하기" class="btn btn-primary my-2">
 </form>
</div>
</html>
  • AnswerForm.java 생성
    package com.mysite.sbb.answer;
import jakarta.validation.constraints.NotEmpty;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class AnswerForm {    
  @NotEmpty(message = "내용은 필수 항목입니다")
  private String content;
}
  • AnswerController.java 수정
    package com.mysite.sbb.answer;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import com.mysite.sbb.question.Question;
import com.mysite.sbb.question.QuestionService;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
@RequestMapping("/answer")
@RequiredArgsConstructor
@Controller
public class AnswerController {
 private final QuestionService questionService;
 private final AnswerService answerService;  
 @PostMapping("/create/{id}")
 public String createAnswer(Model model, @PathVariable("id") Integer id, 
       @Valid AnswerForm answerForm, BindingResult bindingResult) {
    Question question = this.questionService.getQuestion(id);
    if(bindingResult.hasErrors()) {
        model.addAttribute("question", question);
        return "question_detail";
    }
    // TODO: 답변을 저장한다.
    this.answerService.create(question, answerForm.getContent());
    return String.format("redirect:/questiohn/detail/%s", id);
 }
}
    *{...}현재 선택된 객체에 대한 속성에 접근할 때 사용된다. th.object="${
  • form_errors.html 생성
    <div th:fragment="formErrorsFragment" class="alert alert-danger" role="alert" th:if="${#fields.hasAnyErrors()}">
 <div th:each="err : ${#fields.allErrors()}" th:text="${err}" />
</div>
  • question_form.html 수정
    <html layout:decorate="~{layout}">
<div layout:fragment="content" class="container">
 <h5 class="my-3 border-bottom pb-2">질문등록</h5>
 <form th:action="@{/question/create}" th:object="${questionForm}" method="post">
  <div th:replace="~{form_errors :: formErrorsFragment}"></div>
    <div class="mb-3">
       <label for="subject" class="form-label">제목</label>
       <input type="text" th:field="*{subject}" id="subject" class="form-control">
    </div>
    <div class="mb-3">
       <label for="content" class="form-label">내용</label>
       <textarea th:field="*{content}" id="content" class="form-control" rows="10"></textarea>
    </div>
    <input type="submit" value="저장하기" class="btn btn-primary my-2">
 </form>
</div>
</html>
  • question_detail.html 수정
    <html layout:decorate="~{layout}">
<div layout:fragment="content" class="container my-3">
 <!-- 질문-->
 <h2 class="border-bottom py-2" th:text="${question.subject}"></h2> 
 <div class="card my-3">
    <div class="card-body">
       <div class="card-text" style="white-space: pre-line;" th:text="${question.content}"></div>
       <div class="d-flex justify-content-end">
          <div class="badge bg-light text-dark p-2 text-start">
              <div th:text="${#temporals.format(question.createDate, 'yyyy-MM-dd HH:mm')}"></div>
          </div>
       </div>
       </div>
    </div>
 <!-- 답변 개수 표시 -->
 <h5 class="border-bottom my-3 py-2" th:text="|${#lists.size(question.answerList)}개의 답변이 있습니다.|"></h5>
 <!-- 답변 반복 시작 -->
 <div class="card my-3" th:each="answer: ${question.answerList}">
    <div class="card-body">
       <div class="card-text" style="white-space:pre-line;" th:text="${answer.content}"></div>
       <div class="d-flex justify-content-end">
          <div class="badge bg-light text-dark p-2 text-start"> 
             <div th:text="${#temporals.format(answer.createDate, 'yyyy-MM-dd HH:mm')}"></div>   
          </div>
       </div>
       </div>
    </div>
 <!-- 답변 반복 끝 -->
 <!-- 답변 작성-->
 <form th:action="@{|/answer/create/${question.id}|}" th:object="${answerForm}" method="post" class="my-3">
    <div th:replace="~{form_errors :: formErrorsFragment}"></div>
       <textarea th:field="*{content}" rows="10" class="form-control"></textarea>
       <input type="submit" value="답변 등록" class="btn btn-primary my-2"> </form>
 </div>
 </html>
  • 파일 위치
]]> <![CDATA[Spring Boot - JPA와 ORM]]> https://velog.io/@hi_do/Spring-Boot-JPA%EC%99%80-ORM https://velog.io/@hi_do/Spring-Boot-JPA%EC%99%80-ORM Mon, 17 Jun 2024 04:02:22 GMT JPA로 데이터베이스 사용

JPA란?

  • 자바 애플리케이션에서 관계형 데이터베이스와 상호작용하기 위한 표준 API
  • 스프링부트는 JPA(Jav Persistence API)를 사용하여 데이터베이스를 관리한다.
  • 스프링부트는 JPA를 ORM의 기술 표준으로 사용한다.
  • JPA는 인터페이스 모음이므로 이 인터페이스를 구현한 실제 클레스가 필요하다.
  • JPA를 구현한 실제 클래스에는 대표적으로 하이버네이트(Hibernate)가 있다.
  • 하이버네이트는 JPA의 인터페이스를 구현한 실제 클래스이자 자바의 ORM 프레임워크로 부트에서 데이터베이스를 관리하기 쉽게 도와준다.

ORM이란?

  • ORM은 SQL을 사용하지 않고 데이터베이스를 관리할 수 있는 도구
  • ORM은 데이터베이스의 테이블을 자바 클래스로 만들어 관리할 수 있다.

    SQL로 작성시

    insert into question (id, subject, content) values (1, '안녕하세요', '가입 인사드립 니다 ^^);
insert into question (id, subject, content) values (2, '질문 있습니다', 'ORM이 궁금합니다');

    ORM으로 작성시

    Question q1 = new Question();
q1.setId(1);
q1.setSubject("안녕하세요");
q1.setContent("가입 인사드립니다 ^^);
this.questionRepository.save(q1);
Question g2 = new Question();
q2.setId(2);
q2.setSubject("질문 있습니다");
q2.setContent("ORM이 궁금합니다"); this.questionRepository.save(q2);

ORM의 장점

  • ORM을 이용하면 MySQL, 오라클, db, MSSQL과 같은 DBMS의 종류에 관계없이 일관된 자바코드로 사용할 수 있어서 프로그램의 유지보수가 편리하다.

    DBMS란?

  • DBMS(Database Management System) 데이터베이스를 관리하는 소프트웨어이다.
  • DB와 DBMS를 구분하지 않고 사용하는 경우가 많은데 엄밀히 말하면 DB는 데이터를 담은 통이라고 할 수 있고, DBMS는 이 통을 관리하는 소프트웨어이다.

방문자들이 질문과 답변을 남길수 있는 게시판을 제작

  • 사용자의 질문이나 답변을 작성하면 데이터가 생성되는데 이러한 데이터를 관리하려면, 저장, 조회, 수정하는 등의 기능을 구현해야 한다.

  • 데이터를 모으고 관리하는 저장소를 데이터베이스라고 한다.

  • 데이터베이스를 관리하려면 SQL이라는 언어를 사용해야 한다.

  • 스프링부트와 달리 데이터베이스는 자바를 이해하지 못한다.

  • 하지만 ORM(Object Relational Mapping)이라는 도구를 사용하면 자바 문법으로도 데이터베이스를 다룰 수 있다. ORM을 사용하면 개발자는 SQL을 직접 작성하지 않아도 데이터베이스의 데이터를 처리할 수 있다.

  • build.gradle에
    runtimeOnly 'com.h2database:h2'
    추가하고 build.gradle refresh하기
  • application.properties 수정
    spring.application.name=sbb
# DATABASE
#h2콘솔로 접속할 것인지 여부
spring.h2.console.enabled=true
#h2콜솔로 접속하기 위한 경로
spring.h2.console.path=/h2-console
#데이터베이스에 접속하기 위한 경로
spring.datasource.url=jdbc:h2:~/local
#데이터베이스에 접속할때 사용하는 드라이버 클래스 명
spring.datasource.driver-class-name=org.h2.Driver
#데이터베이스에 접속할때 사용하는 아이디
spring.datasource.username=sa
#데이터베이스에 접속할때 사용하는 패스워드 
spring.datasource.password=
  • database 만들기
  • build.gradle refresh
  • 결과
  • 변경 후 연결 클릭
  • 데이터베이스 연결된 결과
  • build.gradle에
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'

  • 추가후 refreash

  • application.properties 에 JPA추가
    spring.application.name=sbb
# DATABASE
#h2콘솔로 접속할 것인지 여부
spring.h2.console.enabled=true
#h2콜솔로 접속하기 위한 경로
spring.h2.console.path=/h2-console
#데이터베이스에 접속하기 위한 경로
spring.datasource.url=jdbc:h2:~/local
#데이터베이스에 접속할때 사용하는 드라이버 클래스 명
spring.datasource.driver-class-name=org.h2.Driver
#데이터베이스에 접속할때 사용하는 아이디
spring.datasource.username=sa
#데이터베이스에 접속할때 사용하는 패스워드 
spring.datasource.password=
# JPA
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.H2Dialect
spring.jpa.hibernate.ddl-auto=update

spring.jpa.hibernate.ddl-auto의 규칙

  • none: 엔티티가 변경되더라도 데이터베이스를 변경하지 않는다.
  • update: 엔티티의 변경된 부분만 데이터베이스에 적용한다.
  • validate: 엔티티와 테이블 간에 차이점이 있는지 검사만 한다.
  • create: 스프링 부트 서버를 시작할 때 테이블을 모두 삭제한 후 다시 생성한다.
  • create-drop: create와 동일하지만 스프링 부트 서버를 종료할 때에도 테이블을 모두 삭제한다.

Entitiy구성

Question(id, subject, content, createDate) Answer

  • Question.java 생성
    package com.mysite.sbb;
import java.time.LocalDateTime;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@Entity
public class Question {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Integer id;    
  @Column(length = 200)
  private String subject;
  @Column(columnDefinition = "TEXT")
  private String content;    
  private LocalDateTime createDate;
}
  • Answer.java 생성
    package com.mysite.sbb;
import java.time.LocalDateTime;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.ManyToOne;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@Entity
public class Answer {
  @Id        // 기본키. 각 데이터들을 구분하는 유효한 값.(중복 불가능)
  @GeneratedValue(strategy = GenerationType.IDENTITY)    //고유한 번호를 생성하는 방법.
  private Integer id;
  //열 이름 텍스트를 열 데이터로 넣을 수 있다. 글자수를 제한할 수 없는 경우에 사용.
  @Column(columnDefinition = "TEXT")
  private String content;
  private LocalDateTime createDate;
  // Question을 참조해야 하기 위해.
  @ManyToOne
  private Question question;
}
  • 결과

    답변을 통해 질문의 제목을 알고 싶다

  • answer.getQuestion().getSubject() -> 접근할 수 있다.
    @ManyToOne
private Question question;

  • 하나의 질문에 답변은 여러개가 달릴 수 있다. 따라서 답변은 Many가 되고 질문은 One이 된다. @ManyToOne을 통해서 N:1관계를 나타낼 수 있다. 이렇게 @ManyToOne을 설정하면 Answer 엔티티의 question속성과 Question 엔티티가 서로 연결된다(실제 데이터베이스에서는 (외래키_foreign key)관계가 생성된다.)

    @ManyToOne은 부모 자식 관계를 갖는 구조에서 사용한다.

  • 여기서 부모는 Question, 자식은 Answer라고 할 수 있다.

  • 외래키란 테이블과 테이블 사이의 관계를 구성할때 연결되는 열을 의미한다.

    반대로 질문에서 답변을 참조할 수 없을까? -> 있다

  • 답변과 질문이 N:1관계라면 질문과 답변은 1:N관계라고 할 수 있다.

  • @OneToMany를 사용하면 된다 질문 하나에 답변은 여러개 이므로 Question 추가할 Answer속성 타입은 List형태로 구성해야 한다.

  • Question.java에 
    @OneToMany(mappedBy = "question", cascade = CascadeType.REMOVE)
private List<Answer> answerList;
    추가 Qustion.java
    package com.mysite.sbb;
import java.time.LocalDateTime;
import java.util.List;
import jakarta.persistence.CascadeType;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.OneToMany;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@Entity
public class Question {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Integer id;    
  @Column(length = 200)
  private String subject;    
  @Column(columnDefinition = "TEXT")
  private String content;    
  private LocalDateTime createDate;    
  @OneToMany(mappedBy = "question", cascade = CascadeType.REMOVE)
  private List<Answer> answerList;    // question.getAnswerList()
}

  • 질문에 답변을 참조하려면 question.getAnswerList()를 호출하면 된다. @OneToMany에 사용된 mappedBy 속성은 참조 엔티티의 속성명을 정의한다.

  • 즉, Answer 엔티티에서 Question 엔티티를 참조한 속성인 question을 mappedBy에 전달해야 한다.

  • Cascade = CascadeType.REMOVE 게시판에서는 질문 하나에 답변이 여러개 작성될 수 있다. 그런데 보통 게시판 서비스에서는 질문을 삭제하면 그에 달린 답변들도 함께 삭제된다. 그렇게 만들기 위해 적용하는 속성이다.

repository로 데이터베이스 관리

  • entity만으로는 테이블의 데이터를 저장, 조회, 수정, 삭제 등을 할 수 없다. 이런 데이터를 관리하려면 데이터베이스와 연동하는 JPA repository가 있어야 한다.
  • QuestionRepository.java(interface) 생성
    package com.mysite.sbb;
import org.springframework.data.jpa.repository.JpaRepository;
// CRUD함수를 JpaRepository가 들고 있음.
// @Repository라는 에너테이션이 없어도 IoC된다. 이유는 JpaRepository를 상속했기 때문
public interface QuestionRepository  extends JpaRepository<Question, Integer>{
}

  • Question 엔티티를 리포지터리로 생성한다는 의미. Question 엔티티의 기본키가 integer타입.

  • AnswerRepository.java(interface) 생성
    package com.mysite.sbb;
import org.springframework.data.jpa.repository.JpaRepository;
public interface AnswerRepository extends JpaRepository<Answer, Integer>{
}
  • build.gradle에
    testImplementation 'org.junit.jupiter:junit-jupiter' 
 testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
    추가 후 refresh
  • IoC(Inversoin of Control) : Spring에서 객체의 생성과 관리를 Spring 컨테이너가 담당 (이전에는 개발자가 객체의 생성과 생명주기를 직접 관리)
  • DI(Dependency Injection) : 필요로하는 객체를 생성하거나 검색하지 않고 외부로부터 주입. Spring의 IoC컨테이너는 애플리케이션의 객체를 생성하고 관리하는데, 이때 의존성주입(DI)를 통해 필요한 Bean을 주입한다.
  • SbbApplicationTests.java 수정
    package com.mysite.sbb;
import java.time.LocalDateTime;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class SbbApplicationTests {    
  @Autowired
  private QuestionRepository questionRepository;
  @Test
  void testJpa() {
      Question q1 = new Question();
      q1.setSubject("sbb가 무엇인가요?");
      q1.setContent("sbb에 대해서 알고 싶습니다");
      q1.setCreateDate(LocalDateTime.now());
      this.questionRepository.save(q1);
      Question q2 = new Question();
      q2.setSubject("스프링 부트 모델 질문입니다");
      q2.setContent("id는 자동으로 생성되나요?");
      q2.setCreateDate(LocalDateTime.now());
      this.questionRepository.save(q2);
  }
}

  • 서버가 이미 켜져있기 때문에 에러

  • 서버 종료 후 다시 실행하면 에러 없음 -> JUnit Test 실행 후 서버 다시 실행

  • 입력 및 실행 결과
  • SbbApplicationTests.java 수정
    package com.mysite.sbb;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.time.LocalDateTime;
import java.util.List;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class SbbApplicationTests {    
  @Autowired
  private QuestionRepository questionRepository;
  @Test
  void testJpa() {
          List<Question> all = this.questionRepository.findAll();
          // assertEquals(기댓값, 실제값) 동일한지 조사.
      assertEquals(2, all.size());        // 데이터개수        
      Question q = all.get(0);        // 첫번째
      assertEquals("sbb가 무엇인가요?", q.getSubject());
      }        
  }
  • SbbApplicationTests.java 수정
    package com.mysite.sbb;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.util.Optional;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class SbbApplicationTests {    
  @Autowired
  private QuestionRepository questionRepository;
  @Test
  void testJpa() {
      // 값이 있는지 없는지에 대한 처리를 확인하는 클래스. (null값을 유연하게 처리)
      // isPresent로 값이 존재하는지 확인할 수 있다.
      // isPresent를 통해 값이 존재한다면 get()을 통해 실제 Question의 값을 얻는다.
      Optional<Question> oq = this.questionRepository.findById(1);
      if(oq.isPresent()) {
          Question q = oq.get();
          assertEquals("sbb가 무엇인가요?", q.getSubject());
      }
      }        
  }
  • QuestionRepository.java (interface) 수정
    package com.mysite.sbb;
import org.springframework.data.jpa.repository.JpaRepository;
// CRUD함수를 JpaRepository가 들고 있음.
// @Repository라는 에너테이션이 없어도 IoC된다. 이유는 JpaRepository를 상속했기 때문
public interface QuestionRepository  extends JpaRepository<Question, Integer>{
  // findBy~
  // select * from question where subject = ?
  Question findBySubject(String subject);    //Jpa Query methods
}
  • SbbApplicationTests.java 수정
    package com.mysite.sbb;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.util.Optional;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class SbbApplicationTests {    
  @Autowired
  private QuestionRepository questionRepository;
  @Test
  void testJpa() {
      Question q = this.questionRepository.findBySubject("sbb가 무엇인가요?");
      assertEquals(1, q.getId());
      }
  }
  • application.properties에
    spring.jpa.properties.hibernate.format_sql=true
spring.jpa.properties.hibernate.show_sql=true
    spring.application.name=sbb
# DATABASE
#h2콘솔로 접속할 것인지 여부
spring.h2.console.enabled=true
#h2콜솔로 접속하기 위한 경로
spring.h2.console.path=/h2-console
#데이터베이스에 접속하기 위한 경로
spring.datasource.url=jdbc:h2:~/local
#데이터베이스에 접속할때 사용하는 드라이버 클래스 명
spring.datasource.driver-class-name=org.h2.Driver
#데이터베이스에 접속할때 사용하는 아이디
spring.datasource.username=sa
#데이터베이스에 접속할때 사용하는 패스워드 
spring.datasource.password=
# JPA
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.H2Dialect
spring.jpa.hibernate.ddl-auto=update
spring.jpa.properties.hibernate.format_sql=true
spring.jpa.properties.hibernate.show_sql=true
    추가 후 결과 -> console창에 결과가 나옴
  • subject와 content를 함께 조회

  • findBySubjectAndContent

  • QuestionRepository.java(interface) 수정
    package com.mysite.sbb;
import org.springframework.data.jpa.repository.JpaRepository;
// CRUD함수를 JpaRepository가 들고 있음.
// @Repository라는 에너테이션이 없어도 IoC된다. 이유는 JpaRepository를 상속했기 때문
public interface QuestionRepository  extends JpaRepository<Question, Integer>{
  // findBy~
  // select * from question where subject = ?
  Question findBySubject(String subject);    //Jpa Query methods
  Question findBySubjectAndContent(String subject, String content);
}
  • SbbApplicationTests.java 수정
    package com.mysite.sbb;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class SbbApplicationTests {    
  @Autowired
  private QuestionRepository questionRepository;
  @Test
  void testJpa() {
      Question q = this.questionRepository
              .findBySubjectAndContent("sbb가 무엇인가요?", "sbb에 대해서 알고 싶습니다.");
      assertEquals(1, q.getId());
      }
  }
  • 실행 및 결과
  • 쿼리메소드 검색사이트 https://docs.spring.io/spring-data/jpa/reference/jpa/query-methods.html
  • subject 열값들 중에 특정 문자열을 포함하는 데이터를 조회

  • Like를 사용 List[Question] findBySubjectLike(String subject);

  • QuestionRepository.java(interface) 수정
    package com.mysite.sbb;
import java.util.List;
import org.springframework.data.jpa.repository.JpaRepository;
// CRUD함수를 JpaRepository가 들고 있음.
// @Repository라는 에너테이션이 없어도 IoC된다. 이유는 JpaRepository를 상속했기 때문
public interface QuestionRepository  extends JpaRepository<Question, Integer>{
  // findBy~
  // select * from question where subject = ?
  Question findBySubject(String subject);    //Jpa Query methods
  Question findBySubjectAndContent(String subject, String content);
  List<Question> findBySubjectLike(String subject);
}
  • SbbApplicationTests.java 수정
    package com.mysite.sbb;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.util.List;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class SbbApplicationTests {    
  @Autowired
  private QuestionRepository questionRepository;
  @Test
  void testJpa() {
      List<Question> qList = this.questionRepository.findBySubjectLike("sbb%");
      Question q = qList.get(0);
      assertEquals("sbb가 무엇인가요?", q.getSubject());
      }
  }
  • 실행 및 결과

  • q1_0.subject like ? escape'' escape'' 구문은 SQL쿼리에서 사용되는 LIKE 연산자와 함께 쓰이는데, 특정 문자가 와일드 카드로 작동하는 것을 방지하기 위해 사용된다. "sbb%" % 기호가 텍스트로 들어가는 것을 방지하기 위해.

  • sbb% : sbb로 시작하는 문자열
  • %sbb : sbb로 끝나는 문자열
  • %sbb% : sbb를 포함하는 문자열
  • SbbApplicationTests.java 수정
    package com.mysite.sbb;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.Optional;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class SbbApplicationTests {    
  @Autowired
  private QuestionRepository questionRepository;
  @Test
  void testJpa() {
      Optional<Question> oq = this.questionRepository.findById(1);
      assertTrue(oq.isPresent());    //괄호 안의 값이 TRUE인지를 테스트
      Question q = oq.get();
      q.setSubject("수정된 제목");
      this.questionRepository.save(q);
      }
  }
  • 실행 및 결과
  • SbbApplicationTests.java 수정
    package com.mysite.sbb;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.time.LocalDateTime;
import java.util.Optional;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class SbbApplicationTests {
 @Autowired
 private QuestionRepository questionRepository;   
 @Autowired
 private AnswerRepository answerRepository;
 @Test
 void testJpa() {
    Optional<Question> oq = this.questionRepository.findById(2);
    assertTrue(oq.isPresent());
    Question q = oq.get();  
    Answer a = new Answer();
    a.setContent("네 자동으로 생성됩니다.");
    a.setQuestion(q);
    a.setCreateDate(LocalDateTime.now());
    this.answerRepository.save(a);
    }
 }
  • 실행 및 결과
  • SbbApplicationTests.java 수정
    package com.mysite.sbb;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.Optional;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class SbbApplicationTests {
 @Autowired
 private QuestionRepository questionRepository;  
 @Autowired
 private AnswerRepository answerRepository;
 @Test
 void testJpa() {
   Optional<Answer> oq = this.answerRepository.findById(1);
   assertTrue(oq.isPresent());
   Answer a = oq.get();
   assertEquals(2, a.getQuestion().getId());
    }
 }
  • 실행 및 결과

  • left join : 연관된 데이터를 접근하기 위한 방법 Answer와 Question은 데이터베이스 내에서 연관관계를 가지고 있다. Answer가 Question을 참조하는 외래키(question_id)를 포함한다. left join을 사용하면 Answer객체를 조회할때 연관된 Question 객체의 정보도 함께 불러올 수 있다.

답변 데이터를 통해 질문 데이터 찾기 vs 질문 데이터를 통해 답변 데이터 찾기

  • a.getQuesetion() : 답변을 통해서 질문 찾기

    질문 데이터를 통해 답변 찾기 -> answerList를 사용

  • org.hibernate.LazyInitializationException: failed to lazily initialize a collection of role: com.mysite.sbb.Question.answerList: could not initialize proxy - no Session

  • QuestionRepository가 findById메서드를 통해 Question 객체를 조회하면 DB세션이 끊어진다. == DB세션이란 스프링부트 애플리케이션과 데이터베이스 간의 연결

  • answerList는 앞서 q객체를 조회할때가 아니라 q.getAnswerList()메서드를 호출하는 시점에 가져오기 때문에 이와 같은 오류가 발생하는 것이다. == 이렇게 데이터를 필요한 시점에 가져오는 방식을 지연(Lazy)방식이라고 한다.
  • 이와 반대로 q객체를 조회할 때 미리 answer 리스트를 모두 가져오는 방식은 즉시(Eager)방식이라고 한다. @OneToMany, @ManyToOne 옵션으로 fetch=FetchType.Lazy 또는 fetch=Fetchtype.EAGER 가져오는 방식을 설정할 수 있다.

  • 이러한 문제는 테스트 코드에서만 발생한다. 실제 서버에서 JPA프로그램들을 실행할때는 DB세션이 종료되지 않아 오류가 발생하지 않는다. 테스트 코드를 수행할때 이런 오류를 방지할 수 있는 방법은 @Transactional 사용하면 된다.

  • @Transactional은 메서드가 종료될 때까지 DB세션을 유지한다.
  • SbbApplicationTests.java 수정
    package com.mysite.sbb;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Optional;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import jakarta.transaction.Transactional;
@SpringBootTest
class SbbApplicationTests {   
 @Autowired
 private QuestionRepository questionRepository;  
 @Autowired
 private AnswerRepository answerRepository;
 @Transactional
 @Test
 void testJpa() {
   Optional<Question> oq = this.questionRepository.findById(2);
   assertTrue(oq.isPresent());
   Question q = oq.get();    
   List<Answer> answerList = q.getAnswerList();
   assertEquals(1, answerList.size());
   assertEquals("네 자동으로 생성됩니다.", answerList.get(0).getContent());
    }
 }
  • 실행 및 결과
  • QuestionController.java 생성
    package com.mysite.sbb.question;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
@Controller
public class QuestionController {  
 @GetMapping("/question/list")
 public String list() {
    return "question_list";
 }
}
  • build.gradle에 
     implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
 implementation 'nz.net.ultraq.thymeleaf:thymeleaf-layout-dialect'
    추가 후 refresh
]]> <![CDATA[SpringBoot - 초기 설정]]> https://velog.io/@hi_do/SpringBoot-%EC%B4%88%EA%B8%B0-%EC%84%A4%EC%A0%95 https://velog.io/@hi_do/SpringBoot-%EC%B4%88%EA%B8%B0-%EC%84%A4%EC%A0%95 Mon, 17 Jun 2024 03:36:15 GMT 스프링 부트?
  • 웹 프로그램(웹 애플리케이션)을 쉽고 빠르게 만들 수 있도록 도와주는 자바의 웹 프레임워크
  • 웹 프로젝트를 완성하기 위해서 많은 기능을 생성해야 한다. (쿠키처리, 로그아웃, 로그인, 데이터베이스 처리 등등)

  • 웹 프레임워크에는 기능들이 이미 만들어져 있다.

  • 웹 프레임워크에 있는 기능을 익혀서 사용하기만 하면되고 흐름을 정확하게 파악하면 된다.

    스프링 부트는 웹 보안적인 부분에서 굉장히 튼튼한 웹 프레임워크이다.

  • SQL 인젝션 : 악의적인 SQL을 주입하여 공격하는 방법, XSS(crose site scripting) : 자바스크립트를 삽입해 공격하는 방법, CSRF(Cross Site Request Forgery) : 위조된 요청을 보내는 공격방법, 클릭재킹(clickjacking): 사용자가 의도하지 않은 클릭을 유도하는 공격방법 보안공격을 막아준다.

프레임워크와 라이브러리의 차이점?

  • 프레임워크

  • 구조 제공: 프레임워크는 소프트웨어의 기본 구조를 제공하며 개발자가 그 구조에 맞춰 코드를 작성 개발의 뼈대를 제공하며, 개발자가 프레임워크의 규칙과 흐름에 따라 개발을 진행

  • 라이브러리

  • 도구 모음: 라이브러리는 특정 기능을 수행하는 도구나 함수들의 모음 개발자가 필요에 따라 호출해서 사용

스프링 부트는 WAS가 필요없다.

  • 스프링만 사용하여 웹 애플리케이션을 개발한다면 실행할 수 있는 톰캣과 같은 WAS(Web Application Server)가 필요하다. 스프링부트에서는 톰캣 서버가 내장되어 있고 설정도 자동 적용이 되기때문에 WAS에 대해서 전혀 신경쓸 필요가 없다.

프로젝트 생성

웹에서 만들어서 프로그램으로 실행할 경우

초기 에러가 나올 경우

클라이언트와 서버 구조

  • 웹브라우저(요청) -> 웹서버가 가지고 있는 html문서 (응답) -> html문서를 클라이언트 예를 들어 크롬 브라우저에서 서버에 요청을 보낼때는 서버의 주소(IP주소) 또는 서버의 주소를 대체할 수 있는 도메인명을 알아야 한다. 예를 들어 주소창에 naver.com을 입력하면 네이버에서 운용하는 웹 서버가 호출되고 서버는 요청에 대한 응답을 브라우저에 돌려준다. 즉, 웹 서버는 요청에 대한 응답으로 html문서나 다른 resourcese들을 브라우저에 표시한다.
  • 프로토콜 : http의 서비스 내용은 웹서비스 포트번호 80
  • https의 서비스 내용 SSL을 적용한 웹 서비스 포트번호 443
  • FTP의 서비스 내용 파일 전송 포트 21 ex) https://www.naver.com/:443

  • 필요에 따라 포트 번호를 변경할 수 있다. 예를 들어 HTTP의 포트번호는 80대신 8080을 사용할 수도 있다.

localhost:8080

  • localhost라는 도메인명이 127.0.0.1이라는 ip주소를 의미

127.0.0.1 ip주소는 내컴퓨터를 의미한다.

package com.mysite.sbb;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;
@Controller
public class HelloController {
    @GetMapping("hello") //localhost:8080/hello
    @ResponseBody
    public String hello() {
        return "Hello World" ;
    }
}

  • developmentOnly : 해당 라이브러리는 개발 환경에만 적용된다는 의미 운영 환경에 배포되는 jar, war 파일에는 이 라이브러리가 포함되지 않는다.

  • intellij에서는 필수

  • 이렇게 나와야 적용완료

Lombok 다운로드

  • Lombok 이란? Lombok은 자바 개발을 위한 라이브러리로, 반복적인 코드를 자동으로 생성해 주어 개발 생산성을 높여주는 도구이다. 자바 개발에서는 보일러플레이트 코드(반복적이고 지루한 코드)가 많이 발생하는데, Lombok을 사용하면 이러한 코드를 줄일 수 있다. https://projectlombok.org/download

  • 입력시 설치 창이 뜬다

  • Install successful 확인

  • build.grade에 

    compileOnly 'org.projectlombok:lombok'
annotationProcessor 'org.projectlombok:lombok'

    추가 후

  • HelloLombok.java 생성 

    package com.mysite.sbb;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
@RequiredArgsConstructor
@Getter
public class HelloLombok {
 private final String hello;
 private final int lombok;  
//    // 모든 final 필드를 초기화하는 생성자
//    public HelloLombok(String hello, int lombok) {
//        this.hello = hello;
//        this.lombok = lombok;
//    }
//   
 public static void main(String[] args) {
    HelloLombok helloLombok = new HelloLombok("헬로",5);     
    System.out.println(helloLombok.getHello());
    System.out.println(helloLombok.getLombok());
 }
}

  • lombok의 @RequiredArgsConstructor 덕분에 초기화하는 생성자를 따로 입력하지 않아도 된다.

src/main/resources 디렉터리

  • templates: html 형식 파일
  • static: css, javascript, jpg 등의 이미지 파일
  • application.properties 파일: 프로젝트의 환경을 설정 (데이터베이스 설정 등)
  • gradle의 Groovy를 기반으로 빌드: Ant, maven과 같은 이전 세대의 단점을 보안하고 장점을 취합해서 만든 환경 파일

####

  • MainController.java 생성
    package com.mysite.sbb;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
@Controller
public class MainController {
  @GetMapping("/sbb")
  public void index() {
      System.out.println("index");
  }
}
  • 결과 There was an unexpected error (type=Internal Server Error, status=500).

  • localhost:8080/sbb를 요청하면 결과값을 리턴을 해야 하는데 아무값도 리턴하지 않아 500오류가 발생한 것이다. 즉, 오류를 해결하려면 응답을 리턴해야 한다.

  • MainController.java 수정
    package com.mysite.sbb;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
@Controller
public class MainController {
  @GetMapping("/sbb")
  @ResponseBody
  public String index() {
      return "index";
  }
}
  • 결과
]]> <![CDATA[Spring - CRUD]]> https://velog.io/@hi_do/Spring-CRUD https://velog.io/@hi_do/Spring-CRUD Thu, 13 Jun 2024 08:58:56 GMT 스프링 프레임워크와 MyBatis, 스프링 MVC를 모두 결합한 프로젝트 진행

MyBatis와 스프링을 이용한 영속처리

  • 영속처리: 데이터를 영구적으로 저장하고 유지 1) VO 선언 2) Mapper 3) xml 4) 테스트 코드

Todo기능 개발

  • 등록작업 TodoMapper -> TodoService -> TodoController ->jsp 순서로 진행

    TodoMapper

  • TodoMapper.java
  • TodoMapper.xml
  • TodoMapperTests.java

    TodoService

  • TodoService.java
  • TodoServiceImpl.java
  • TodoServiceTests.java

    TodoController

  • TodoController.java
    package org.zerock.springex.controller;
import org.zerock.springex.dto.TodoDTO;
import jakarta.validation.Valid;
import org.springframework.stereotype.Controller;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import lombok.extern.log4j.Log4j2;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;
@Controller
@RequestMapping("/todo")
@Log4j2
public class TodoController {
  @RequestMapping("/list")
  public void list() {
      log.info("todo list...............");
  }
  @GetMapping("/register")
  public void registerGET() {
      log.info("GET todo register~~~~~");
  }
  @PostMapping("/register")
  public String registerPost(@Valid TodoDTO todoDTO, BindingResult bindingResult,
                             RedirectAttributes redirectAttributes ) {
      log.info("POST todo register~~~~~");
      if(bindingResult.hasErrors()) {
          log.info("has errors!!!!!!!");
          redirectAttributes.addFlashAttribute("errors", bindingResult.getAllErrors());
          return "redirect:/todo/register";
      }
      log.info(todoDTO);
      return "redirect:/todo/list";
  }
}

    jsp

  • register.jsp
    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <!-- Bootstrap CSS -->
  <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-1BmE4kWBq78iYhFldvKuhfTAU6auU8tT94WrHftjDbrCEXSU1oBoqyl2QvZ6jIW3" crossorigin="anonymous">
  <title>Hello, world!</title>
</head>
<body>
<div class="container-fluid">
  <div class="row">
      <!-- 기존의 <h1>Header</h1> -->
      <div class="row">
          <div class="col">
              <nav class="navbar navbar-expand-lg navbar-light bg-light">
                  <div class="container-fluid">
                      <a class="navbar-brand" href="#">Navbar</a>
                      <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#navbarNavAltMarkup" aria-controls="navbarNavAltMarkup" aria-expanded="false" aria-label="Toggle navigation">
                          <span class="navbar-toggler-icon"></span>
                      </button>
                      <div class="collapse navbar-collapse" id="navbarNavAltMarkup">
                          <div class="navbar-nav">
                              <a class="nav-link active" aria-current="page" href="#">Home</a>
                              <a class="nav-link" href="#">Features</a>
                              <a class="nav-link" href="#">Pricing</a>
                              <a class="nav-link disabled">Disabled</a>
                          </div>
                      </div>
                  </div>
              </nav>
          </div>
      </div>
      <!-- header end -->
      <!-- 기존의 <h1>Header</h1>끝 -->
      <div class="row content">
          <div class="col">
              <div class="card">
                  <div class="card-header">
                      Featured
                  </div>
                  <div class="card-body">
                      <form action="/todo/register" method="post">
                          <div class="input-group mb-3">
                              <span class="input-group-text">Title</span>
                              <input type="text" name="title" class="form-control" placeholder="Title">
                          </div>
                          <div class="input-group mb-3">
                              <span class="input-group-text">DueDate</span>
                              <input type="date" name="dueDate" class="form-control" placeholder="Writer">
                          </div>
                          <div class="input-group mb-3">
                              <span class="input-group-text">Writer</span>
                              <input type="text" name="writer" class="form-control" placeholder="Writer">
                          </div>
                          <div class="my-4">
                              <div class="float-end">
                                  <button type="submit" class="btn btn-primary">Submit</button>
                                  <button type="result" class="btn btn-secondary">Reset</button>
                              </div>
                          </div>
                      </form>
                      <script>
                          const serverValidResult = {}
                          <c:forEach items="${errors}" var="error">
                          serverValidResult['${error.getField()}'] = '${error.defaultMessage}'
                          </c:forEach>
                          console.log(serverValidResult)
                      </script>
                  </div>
              </div>
          </div>
      </div>
  </div>
  <div class="row content">
      <h1>Content</h1>
  </div>
  <div class="row footer">
      <!--<h1>Footer</h1>-->
      <div class="row   fixed-bottom" style="z-index: -100">
          <footer class="py-1 my-1 ">
              <p class="text-center text-muted">Footer</p>
          </footer>
      </div>
  </div>
</div>
<script src="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/js/bootstrap.bundle.min.js" integrity="sha384-ka7Sk0Gln4gmtz2MlQnikT1wXgYsOg+OMhuP+IlRH9sENBO0LRn5q+8nbTov4+1p" crossorigin="anonymous"></script>
</body>
</html>
  • web.xml
    <?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/web-app_5_0.xsd"
       version="5.0">
  <context-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>/WEB-INF/root-context.xml</param-value>
  </context-param>
  <listener>
      <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <servlet>
      <servlet-name>appServlet</servlet-name>
      <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
      <init-param>
          <param-name>contextConfigLocation</param-name>
          <param-value>/WEB-INF/servlet-context.xml</param-value>
      </init-param>
      <init-param>
          <param-name>throwExceptionIfNoHandlerFound</param-name>
          <param-value>true</param-value>
      </init-param>
      <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
      <servlet-name>appServlet</servlet-name>
      <url-pattern>/</url-pattern>
  </servlet-mapping>
  <filter>
      <filter-name>encoding</filter-name>
      <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
      <init-param>
          <param-name>encoding</param-name>
          <param-value>UTF-8</param-value>
      </init-param>
  </filter>
  <filter-mapping>
      <filter-name>encoding</filter-name>
      <servlet-name>appServlet</servlet-name>
  </filter-mapping>
</web-app>

hibernate-validator @NotNull: 필드나 메서드 매개변수가 null이 아니어야 함을 나타냅니다. @Null: Null만 입력 가능 @NotEmpty: 문자열, 배열, 컬렉션 등이 비어 있지 않아야 함을 나타냅니다. @NotBlank: 문자열 필드가 비어 있지 않아야 함을 나타냅니다. @Pattern(regexp): 정규식 패턴을 사용하여 문자열의 형식을 검사합니다. @Size(min, max): 문자열, 배열, 컬렉션의 길이 또는 크기에 대한 제약을 설정합니다. @Min(value): 숫자 형식의 필드가 지정된 최소 값 이상이어야 함을 나타냅니다. @Max(value): 숫자 형식의 필드가 지정된 최대 값 이하여야 함을 나타냅니다. @Past: 날짜와 시간 필드가 현재 날짜 이전인지 확인합니다. @Future: 날짜와 시간 필드가 이후인지 확인합니다. @Positive: 양수만 가능 @PositiveOrZero: 양수와 0만 가능 @Negative: 음수만 가능 @NegativeOrZero: 음수와 0만 가능 @Email: 이메일 주소의 유효성을 검사합니다. @AssertTrue, @AssertFalse: 논리 값 (true 또는 false)를 검사합니다. @CreditCardNumber: 신용 카드 번호의 유효성을 검사합니다. @Length(min, max): 문자열의 길이 제한을 설정합니다. @Range(min, max): 숫자 필드가 지정된 범위 내에 있어야 함을 나타냅니다.

valid를 이용한 검증

  • 유효성 검사를 자바스크립트를 했었지만 모바일과 같은 다양한 환경에서 서버를 이용하는 현재에는 브라우저를 사용하는 프론트쪽에서의 검증과 더불어 백서버에서도 입력되는 값들을 검증하는 것이 일반적이다.
  • 이러한 검증 작업은 컨트롤러에서 진행하는데 스프링 MVC의 경우 @Valid와 BindingResult라는 것을 이용해서 간단하게 처리할 수 있다.
  • @Valid의 애너테이션을 이용해서 검증하고, BindingResult는 스프링 프레임워크에서 유효성 검사 후에 발생하는 오류 및 검증 결과를 저장
  1. @Valid annotion을 사용한 모델 객체 검증
  2. BindingResult에 검증에 대한 결과를 저장
  3. RedirectAttribute 리다이렉트 한 후 데이터 전달 순서를 지켜 사용하면 스프링 mvc는 유효성 검사를 수행하고 유효성 검사 결과를BindingResult 에 저장한 후 리다이렉트 한 후에 데이터를 RedirectAttributes를 통해 안전하게 전달할 수 있다

checkbox를 Formatter

  • 화면에서 체크박스를 이용해서 완료여부(finished)를 처리. 문제는 브라우저가 체크박스가 클릭된 상태 전송되는값이 'on'이라는 값을 전달한다. TodoDTO로 데이터를 수집할때 문자열 'on'을 boolean타입으로 처리할 수 있어야 한다.
  • 컨트롤러에서 데이터를 수집할 때 타입을 변경해줘야 한다.

페이징 처리

  • 가져오는수 select * from tbl_todo order by tno desc limit 10;
  • 첫번째 10 건너뛰는 데이터수(skip), 두번째 10가져오는 데이터수 (fetch) 2페이지 == select * from tbl_todo order by tno desc limit 10, 10; 5페이지 == select * from tbl_todo order by tno desc limit 40, 10;
  • 전체 데이터 개수 select count(tno) from tbl_todo;

페이징 처리를 위한 DTO(PageRequestDTO)

  • 현재 페이지의 번호(page)
  • 한페이지당 보여주는 데이터의 수(size)
    package com.springex.dto;
import jakarta.validation.constraints.Max;
import jakarta.validation.constraints.Min;
import jakarta.validation.constraints.Positive;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
public class PageRequestDTO {
  @Builder.Default    // 필드에 기본값 설정
  @Min(value = 1)     // 최솟값
  @Positive           // 양수여야 한다.
  private int page = 1;// 현재 페이지 번호
  @Builder.Default    // 필드에 기본값을 설정
  @Min(value = 10)    // 최솟값 10
  @Max(value = 100)   // 최댓값 100
  @Positive
  private int size = 10;  //한페이지당 보여주는 데이터의 수
  public int getSkip() {
      // 일반적으로 데이터베이스나 컬렉션에서 데이터를 가져올때
      // 0부터 시작하는 인덱스를 사용하는 경우가 많아서
      // 페이지를 가져오려면 인덱스 0번부터 시작해야 한다.
      // ex)페이지번호 1이면 (1-1)*10 은 0 -> 첫번째 페이지의 데이터를 가져올때 사용
      // 페이지번호가 2이면 (2-1)*10 -> 10부터는 두번째 페이지의 데이터를 가져올때 사용
      return (page -1) * 10;
  }
}

TodoMapper의 count 처리

  • 화면에 페이지 번호들을 구성하기 위해서는 전체 데이터의 수를 알아야만 가능하다. 예를 들어 마지막 페이지가 7에서 끝나야 하는 상황이 생긴다면 화면상에서도 페이지 번호를 조절해야 하기 때문이다.

PageResponseDTO

  • TodoDTO의 목록
  • 전체 데이터 수
  • 페이지 번호의 처리를 위한 데이터들(시작 페이지 번호/ 끝 페이지 번호)
  • 화면상에서 페이지 번호들을 출력하려면 현재 페이지번호(page)와 페이지당 데이터 수(size)를 이용해서 계산해야 한다.
  • PageResponseDTO는 생성자를 통해서 필요한 page나 size등을 전달받도록 구성한다

페이지 번호의 계산

  • 페이지 번호를 계산하려면 현재 페이지의 번호(page)가 필요
  • 화면에 10개의 페이지 번호를 출력한다고 했을 때 경우의 수들이 발생한다 1) page가 1인 경우: 시작페이지(start)는 1, 마지막페이지(end)는 10 1) page가 10인 경우: 시작페이지(start)는 1, 마지막페이지(end)는 10 1) page가 11인 경우: 시작페이지(start)는 11, 마지막페이지(end)는 20
  • 마지막 페이지/시작페이지 번호의 계산 흔히들 처음에 구해야 하는 것이 start라고 생각하지만, 마지막 패아자(end)를 구하는 계산이 더 편할 수 있다.
  • end는 현재 페이지 번호를 기준으로 계산한다.
  • 마지막 페이지를 먼저 계산한 이유가 시작페이지(start)의 계산을 쉽게 하기 위함. 시작페이지(start)의 경우 계산한 마지막 페이지에서 9를 빼면 된다. this.start = this.end -9 10-9=1 20-9=11
  • 시작페이지의 구성은 끝났지만 마지막 페이지의 경우 다시 전체 개수(total)를 고려해야 한다. 만일 10개씩(size) 보여주는 경우 전체 개수(total)가 75라면 마지막 페이지는 10이 아닌 8이 되어야 한다.
    int last = (int)(Math.ceil((total/(double)size)));
123 / 10.0 => 12.3 => 13
100 / 10.0 => 10.0 => 10
75 / 10.0 => 7.5 => 8
  • 마지막 페이지(end)는 앞에서 구한 last 값보다 작은 경우에는 last값이 end가 되어야한다
    end 7
last9
7 > 8
// last가 최종이어야한다
int last = (int)(Math.ceil((total/(double)size)));
this.end = end > last ? last: end;
  • 이전(prev)/다음(next) 계산 이전페이지의 존재 여부는 시작 페이지(start)가 1이 아니라면 무조건 true가 되어야 한다 (1페이지부터 시작이고 아니라면 2,3,4,, 이기 때문에 페이지가 존재하고 있다)
  • 다음(next)은 마지막 페이지(end)와 페이지당 개수(size)를 곱한 값보다 전체 개수(total)가 더 많으면 다음(next)가 더 있다고 판단해야 한다.
    this.prev = this.start >1;
this.next = total > this.end * this.size;

조회페이지로의 이동

  • 목록 페이지는 특정 Todo의 제목(title)을 누르면 조회 페이지로 이동됨
  • 기존에는 단순히 tno만을 전달해서 '/todo/read?tno=22'과 같은 방식으로 이동했지만 페이지 번호가 붙을 때는 page와 size 같이 전달이 되어야만 조회 페이지에서 다시 목록 이동할대 기존 페이지를 볼 수 있게 된다

수정/삭제 처리 후 페이지 이동

  • 수정/삭제 작업은 POST방식으로 처리되고 삭제 처리가 된 후에는 다시 목록으로 이동해야 한다. 그렇기 때문에 수정 화면에서[form] 태그로 데이터를 전송할때 관련 정보를 같이 추가해서 전달해야만 한다.
    <input type="hidden" name="page" value="${pageRequestDTO.page}">
<input type="hidden" name="size" value="${pageRequestDTO.size}">
    post 방식으로 이루어지는 삭체 처리도 PageRequestDTO를 이용해서 [form] 태그로 전송되는 태그들을 수집하고 수정 후에 목록페이지로 이동할 때 page는 무조건 1페이지로 이동하도록 만들 수 있다
  • 수정 처리 후 이동 Todo를 수정한 후에 목록으로 이동할때 페이지 정보를 이용해야 TodoController의 Modify()에서 PageRequestDTO를 받도록 구현한다
]]> <![CDATA[Spring 2024.06.12]]> https://velog.io/@hi_do/Spring https://velog.io/@hi_do/Spring Wed, 12 Jun 2024 04:03:47 GMT ApplicationContext
  • 서블릿이 존재하는 공간을 서블릿 컨텍스트라고 했다. 스프링에서는 빈(Bean)이라고 부르는 객체를 관리하기 위해서 ApplicationContext라는 존재를 활용해야 한다.
  • ApplicationContext는 root-context.xml을 이용해서 스프링이 실행되고 ApplicationContext 객체가 생성된다.
  • root-context.xml을 읽으면 SampleService와 SampleDAO가 [bean]으로 지정 되어있어 해당 클래스의 객체를 생성해서 관리하기 시작한다.

Context:component-scan

  • 스프링을 이용할때는 클래스를 작성하거나 객체를 직접 생성하지 않는다. 이 역할은 스프링 내부에서 이루어지며 ApplicationContext가 생성된 객체들을 관리한다.
  • 개발자가 직접 객체를 생성하지 않는 방식이 서블릿과도 유사하다. 서블릿을 생성하면 톰캣이 웹 애플리케이션을 실행하고 필요할 때 서블릿 객체를 만드는 것과 비슷한 방식이다.

@Service, @Repository

  • 서블릿에서도 @WebServlet이나 @WebFilter와 같은 다양한 에너테이션이 존재하듯이 스피링 프레임워크는 애플리케이션 전체를 커버하기 때문에 다양한 종류의 네너테이션을 사용하도록 작성되어 있다.
  • @Controller: MVC의 컨트롤러를 위한 에너테이션 @Serive: 서비스 계층의 객체를 위한 에너테이션 @Repository: DAO와 같은 객체를 위한 에너테이션 @Component: 일반 객체나 유틸리티객체를 위한 에너테이션
  • 에너테이션 이름으로 스프링이 사용하는 웹 영역뿐만 아니라 애플리케이션 전체에 사용할수 있는 객체들을 망라하고 있다.

생성자 주입 방식

  • 초기 스프링에서는 @Autowired를 멤버 변수로 할당하거나 Setter를 작성하는 방식으로 이용했지만, 스피링 3 이후에는 생성자 주입 방식이라고 부르는 방식을 더 많이 활용하고 있다.
  • 생성자 주입 방식 규칙 1) 주입 받아야하는 객체의 변수는 final로 작성되어야 한다. 2) 생성자를 이용해서 해당 변수를 생성자의 파라미터로 지정한다.
  • Lombok에는 생성자 주입을ㅇ 간단히 작성할 수 있는데 @RequiredArsContructor를 이용해서 필요한 생성자를 자동으로 작성할 수 있다.

인터페이스를 이용한 느슨한 결합

  • 스프링이 의존성 주입을 가능하게 하지만 좀 더 근본적으로 유연한 프로그램을 설계하기 위해서는 인터페이스를 이용해서 나중에 다른 클래스의 객체로 쉽게 변경할 수 있도록 하는 것이 좋다.
  • 예를 들어 SampleDAO를 다른 객체로 변경하려면 결론적으로 SampleSerice 코드 역시 수정되어야 한다. 추상화 된 타입을 이용하면 이러한 문제를 피할 수 있는데 가장 대표적인 것이 인터페이스이다. 인터페이스를 이용하면 실제 객체를 모르고 타입만을 이용해서 코드를 작성하는 일이 가능하다.
  • 객체와 객체의 의존 관계의 실제 객체를 몰라도 가능하게 하는 방식을 느슨한 결합이라고 한다.
  • 느슨한 결합을 이용하면 나중에 SampleDAO 타입의 객체를 다른 객체로 변경하더라도 SampleService 타입을 이용하는 코드는 수정할 일이 없기때문에 보다 유연한 구조가 된다.

@Qualifier

  • 이름을 지정해서 특정한 이름의 객체를 주입받는 방식.
  • Lombok과 @Qualifier를 같이 사용하기 위한 방법.
  • main > java > lombok.config 파일 생성
  • lombok.copyableAnnotations += org.springframework.beans.factory.annotation.Qualifier

스프링의 빈(Bean)으로 지정되는 객체들

  • 객체들은 쉽게 말해서 ‘핵심 역할’을 하는 객체들이다
  • 스프링의 빈으로 등록되는 객체들은 오랜 시간 동안 프로그램 내에서 상주하면서 중요한 역할을 하는 객체들이다
  • 반대로 말하면, 역할이 아닌 데이터를 중심으로 두고 설계되는 객체들(DTO,VO)은 Bean으로 등록하지 않는다. 특히 DTO의 경우에는 생명주기가 짧고, 데이터 보관이 주된 역할이기 때문에 빈으로 처리하지 않는다
  • ApplicationContext가 웹 애플리케이션에서 동작하려면 웹 애플리케이션이 실행될때 스프링을 로딩해서 해당 웹 애플리케이션 내부에 스프링의 ApplicationContext를 생성하는 작업이 필요하게 되는데 이를 위해서는 web.xml을 이용해서 리스너를 설정한다.
  • 톰캣과 스프링을 연동하는 구조를 완성
  • 데이터베이스 관련 설정을 추가해야 한다.
    public enum ConnectionUtil {
  INSTANCE;
  private HikariDataSource ds;
  ConnectionUtil() {
      HikariConfig config = new HikariConfig();       config.setDriverClassName("org.mariadb.jdbc.Driver");        config.setJdbcUrl("jdbc:mariadb://localhost:3307/webdb");
      config.setUsername("webuser");
      config.setPassword("webuser");  config.addDataSourceProperty("cachePrepStmts", "true");      config.addDataSourceProperty("prepStmtCacheSize", "250");      config.addDataSourceProperty("prepStmtCacheSqlLimit", "2048");
      ds = new HikariDataSource(config);
  }
      public Connection getConnection()throws Exception{
          return ds.getConnection();
      }
}

  • 스프링을 이용한다면 이 설정을 스프링의 빈으로 처리되어야 한다

  • root-context.xml

  • 빈으로 설정이 되어야 하는 패키지 처리. 데이터베이스의 설정 연결

  • 스프링은 필요한 객체를 스프링에서 주입해 주기 때문에 개별적으로 클래스를 작성해서 빈(bean)으로 등록해 두기만 하면 원하느 곳에서 쉽게 다른 객체를 사용할 수 있다.
  • 이런 특징으로 인해 스프링은 웹이나 데이터베이스와 같은 특정한 영역이 아닌 전체 애플리케이션의 구조를 설계할 때 사용된다.

JDBC -> MyBatis를 이용해서 프로젝트에 적용

  • PreparedStatement, ResultSet, Connection의 처리를 안해도 된다,
  • SQL을 분리하여 선언할 수 있다.
  • MyBatis를 위한 라이브러리

  • 스프링관련: spring-jbdc, spring-tx MyBatis: mybatis, mybatix-spring

  • MyBatis를 위한 스프링의 설정(SqlSessionFactory)_root-context.xml에 MyBatis와 스프링을 연동하고 Mapper 인터페이스를 이용하는 방식
  • 스프링과 MyBatis 사이에 'mybatis-spring'이라는 라이브러리를 이용해서 스프링이 데이터베이스 전체에 대한 처리를 하고 MyBatis는 일부 기능 개발에 활용하는 방식. 개발 시에는 Mapper 인터페이스 방식을 이용해서 인터페이스만으로 모든 개발이 가능한 방식

@AutoWired(required = false)

  • 해당 객체를 주입받지 못하더라도 예외가 발생하지 않는데, 인텔리제이, 이클립스의 경우 @Service, @Repository와 같이 직접 스프링의 빈(Bean)으로 등록된 경우가 아니면 경고가 발생하므로 이를 방지하기 위해 사용된다.

xml로 SQL 분리하기

  • MyBatis를 이용할때 sql은 @Select와 같은 에너테이션을 이용해서 사용하기도 하지만 대부분은 sql을 별도의 파일로 분리하는 것을 권장한다.

  • xml을 사용하는 이유는 sql이 길어지면 이를 에너테이션으로 처리하기가 복잡하기 때문이기도 하고 에너테이션이 나중에 변경되면 프로젝트 전체를 다시 빌드하는 작업이 필요하기 때문에 단순 파일로 사용하는 것이 편리하다. [property name="mapperLocations" value="classpath:/mappers/*/.xml"][/property] xml mapper 파일의 위치

  • classpath 접두어를 이용해서 인식되는 경로이고 mappers 폴더 밑에 폴더가 있어도 관계없도록 '*'와 '.xml'을 지정

순서

1.

    implementation 'org.mybatis:mybatis:3.5.15'
    implementation 'org.mybatis:mybatis-spring:3.0.3'
    implementation 'org.springframework:spring-jdbc:6.1.2'
    implementation 'org.springframework:spring-tx:6.1.2'
  1. root-context.xml에
     <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
     <property name="dataSource" ref="dataSource" />
 </bean>
  2. 애너테이션으로 설정
    package springex.mapper;
import org.apache.ibatis.annotations.Select;
public interface TimeMapper {
@Select("select now()")
String getTime();
}
  3. root-context.xml에 mybatis:scan을 인식할수 있도록 등록
    xmlns:mybatis="http://mybatis.org/schema/mybatis-spring"
http://mybatis.org/schema/mybatis-spring http://mybatis.org/schema/mybatis-spring.xsd">
<mybatis:scan base-package="com.springex.mapper"></mybatis:scan>
  4. 인식하는지 tests 작성
    @Log4j2
@ExtendWith(SpringExtension.class)
@ContextConfiguration(locations="file:src/main/webapp/WEB-INF/root-context.xml")
public class TimeMapperTests 
@Autowired(required = false)
private TimeMapper timeMapper;
@Test
public void testGetTime() {
   log.info(timeMapper.getTime());
}
}
  5. 애너테이션으로 하는 방법말고 xml로 sql분리하는 방법을 사용.
    springex > mapper 패키지생성 > TimeMapper2.interface
package springex.mapper;
public interface TimeMapper2 {
String getNow();
}
  6. main > resources > mappers 디렉터리 추가후 TimeMapper2.xml 생성
    <?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
     PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
     "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.springex.mapper.TimeMapper2">
 <select id="getNow" resultType="string">
     select now()
 </select>
</mapper>
  7. root-context.xml에 MyBatis 설정에 xml 파일을 인식하도록 설정 추가
    <property name="mapperLocations" value="classpath:/mappers/**/*.xml"></property>

스프링 웹 MVC

  • DispatcherServlet과 Front Controller

  • 요청(Request)이 오면 반드시 DispatcherServlet라는 존재를 통해서 실행이 된다.

  • 결론은 스프링 MVC에서는 DispatcherServlet이라는 객체가 프론트 컨트롤러의 역할을 수행한다

root-context.xml

  • 애플리케이션의 핵심적인 빈
  • 데이터베이스 연결, 서비스 계층 구성 등의 애플리케이션의 전반에 걸친 설정 정의

servlet-context.xml

  • 스프링 mvc의 DispatcherServlet에 의한 처리되는 설정을 담당

web.xml

  • 웹 애플리케이션의 배치 설명자(Deployment Descriptor)로서, 서블릿 컨테이너에 애플리케이션을 배포할때 필요한 구성 요소를 정의
  • Servlet, Filter, Listener와 같은 웹 구성 요소의 매핑 및 설정
  • ApplicationContext 구성하기 위해[Listener] 초기화 설정
  • [servlet] 설정은 DispatcherServlet을 등록하는데 DispatcherServlet이 로딩할 때 servlet-context.xml을 이용하도록 설정한다.

@RequestMapping

  • 스프링 컨트롤러에서 가장 많이 사용하는 애너테이션
  • 특정 경로의 요청을 지정하기 위해서 사용
  • 참고로 servlet 중심의 MVC는 Servlt의 상속받아서 doGET(), doPost()와 같은 제한적인 메서드를 오버라이드해서 사용한다
  • 스프링 MVC의 경우 하나의 컨트롤러를 이용해서 여러 경로의 호출 모두 처리할 수 있다.

파라미터 자동 수집과 변환

  • 파라미터 자동 수집은 DTO나 VO등을 메서드의 파라미터로 설정하면 자동으로 전달되는 HttpServletRequest의 파라미터들을 수집해 주는 기능이다.
  • (Failed to convert value of type 'java.lang.String'to required type 'java.time.LocalDate') -> 특정한 타입을 처리하는 Formatter라는 것을 이용해야 한다. 문자열을 포맷해서 특정한 객체로 변환하는 경우에 사용할 수 있다.
  • <mvc:annotation-friven conversion-service="conversionService"/> conversionServie라는 빈(Bean)을 등록한 후에 스프링MVC를 처리할 때 이용하겠다.

객체 자료형의 파라미터 수집

  • 기본 자료형과 달리 객체 자료형을 파라미터로 처리하기 위해서는 객체가 생성되고 setXXX()을 이용해서 처리한다
  • Lombok을 활용하여 @Setter, @Date를 이용하여 처리할 수 있다.

Model

  • 서블릿 request.setAttibute()를 이용해서 데이터 담아서 jsp까지 전달
  • 스프링 MVC에서는 Model이라는 객체를 이용해서 처리한다
  • Java Beans와 @ModelAttribute 스프링 MVC 컨트롤러는 특이하게도 파라미터로 getter/setter를 이용하는 Java Beans의 형식의 사용자 정의 클래스가 파라미터 인 경우에는 자동으로 화면까지 객체를 전달한다. 파라미터로 TodoDTO를 받는 경우에

RedirectAttributes

  • Post 방식으로 처리를 하고 Redirect를 해서 get방식으로 특정한 페이지로 이동하는 PRG패턴
  • 스프링 MVC에서는 RedirectAttributes 로 처리한다 1) addAttribute(키,값): 리다이렉트할 때 쿼리 스트링이 되는 값을 지정 2) addFlashAttribute(키,값): 일회용으로만 데이터를 전달하고 삭제되는 값을 지정
  • addAttribute()로 데이터를 추가하면 리다이렉트할 URL에 쿼리 스트링 추가되고, addFlashAttribute()를 이용하면 URL에 보이지는 않지만, JSP에서는 일회용으로 사용할 수 있다.

스프링 MVC의 예외 처리

  • 컨트롤러에서 발생하는 예외를 처리할 때 가장 일반적인 방식은 @ControllerAdvice를 사용하는 방식이다.
  • @ControllerAdvice가 선언된 클래스는 스프링의 Bean으로 처리된다
  • @ExceptionHandler: 어떤 exception인지 인지하는 에너테이션
  • @ResponseBody: 문자열,JSON타입을 그대로 브라우저에 전송하는 방식

404상태에 맞는 화면을 별도로 맘ㄴ들 경우

  • CommonExceptionAdvice에 추가

    @ExceptionHandler(NoHandlerFoundException.class)
  @ResponseStatus(HttpStatus.NOT_FOUND)
  public String notFound(){
      return "custom404";
  }

  • views > custom404.jsp 파일 생성 WEB-INF > web.xml 수정

    <h1>페이지를 찾을 수 없습니다!</h1>

<servlet>

      <servlet-name>appServlet</servlet-name>
      <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
      <init-param>

          <param-name>contextConfigLocation</param-name>
          <param-value>/WEB-INF/servlet-context.xml</param-value>
      </init-param>

      <init-param>
          <param-name>throwExceptionIfNoHandlerFound</param-name>
          <param-value>true</param-value>
      </init-param>


    <load-on-startup>1</load-on-startup>
</servlet>

서버 다시 돌리고 주소 잘못치면 "페이지를 찾을수 없습니다!" 나온다. ```

]]>