choigoyo_o.log

[flutter] MacOs Sequioa 15.0 업데이트 후 Xcode error

Sat, 21 Sep 2024 12:43:22 GMT

evaluateJavaScript(_:completionHandler:)

해당 오류는

// 변경 할 코드 
 public override func evaluateJavaScript(_ javaScriptString: String, completionHandler: ((Any?, Error?) -> Void)? = nil) {

// 변경 코드
 public override func evaluateJavaScript(_ javaScriptString: String, completionHandler: (@MainActor @Sendable (Any?, (any Error)?) -> Void)? = nil) {

위 처럼 코드를 수정해주면 InAppWebView 에서 발생하는 오류는 사라진다.

include of non-modular error

https://stackoverflow.com/questions/66148505/flutter-include-of-non-modular-header-inside-framework-module-firebase-core-fl 글을 참고하여 오류를 수정하였음

Command PhaseScriptExecution failed with a nonzero exit code

이 오류가 발생했을 때 여러 글에서 사진의 44번째 줄의

// 1번 코드 
source="$(readlink "${source}")"

// 수정을 권한 2번 코드 
source="$(readlink -f "${source}")"

1번 코드를 2번 코드로 -f 를 추가하면 된다고 하였지만 코드에는 이미 -f가 추가되어있는 상태였다

해당 오류는

Runner - TARGETS의 Runner - build Phases - FlutterFire: "flutterfire upload-crashlytics-symbols" 에서 Run script 체크란에 For install builds only 옵션을 체크하여 해결하였다...

Flutter SingleChildScrollView 내부에 Expanded 위젯 사용시 에러 해결방법

Mon, 18 Dec 2023 05:07:11 GMT

화면 비율에따라 맞춰 구현하려 expanded를 사용하였는데 키보드를 사용해야 하는 경우가 생겨 SingleChildScrollView를 사용하려하니 overflow 문제가 생겼었다. 해당 문제에 대해서는 CustomScrollView를 사용하여 해결하였다.

https://api.flutter.dev/flutter/widgets/CustomScrollView-class.html

CustomScrollView(
  slivers: [
    SliverFillRemaining(
      hasScrollBody: false,
      child: Column(
        children: [
          const Text('hellooo'),
          Expanded(child: Container(color: Colors.red)),
          Expanded(child: Container(color: Colors.red)),
          Expanded(child: Container(color: Colors.red)),
          const Text('hello'),
        ],
      ),
    ),
  ],
)

Xcode 에서 B/BL out of range 135384124 (max +/-128MB) to '' 를 해결한 방법

Fri, 20 Oct 2023 01:58:36 GMT

xcode

아래 두가지 오류를 해결한 방법

Linker command failed with exit code 1 (use -v to see invocation)

B/BL out of range 135384124 (max +/-128MB) to ''

TARGETS

Runner → build Settings → Linking - General → Other Linker Flags

에서 + 를 눌러 아래 코드를 추가 해준다

-ld64

문자, 문자열 리터럴 그리고 문자열 결합 개념정리

Tue, 23 May 2023 11:24:07 GMT

문자, 문자열 리터럴 그리고 문자열 결합

문자

문자는 단일한 문자를 나타내는 데이터 타입입니다. 자바에서 문자는 char 데이터 타입으로 표현되며, 작은따옴표 ''로 감싸서 표기합니다.

char c = 'A';
System.out.println(c); // 출력: A

char c1 ='AB'; // 에러

문자열

문자열은 여러 개의 문자로 구성된 데이터 타입입니다. 자바에서 문자열은 String 클래스로 표현되며, 큰따옴표 ""로 감싸서 표기합니다.

String str = "Hello";
System.out.println(str); // 출력: Hello

문자열은 연속된 여러 문자로 볼 수 있습니다.

String s = "A";
String s1 = ""; // 허용
char = ''; // 에러

문자열 결합

문자열과 문자열 결합 : 두 개의 문자열을 결합하여 새로운 문자열을 생성합니다.

String str1 = "Hello";
String str2 = "World";
String result = str1 + str2;
System.out.println(result); // 출력: HelloWorld

문자열과 다른 데이터 타입 결합: 문자열과 다른 데이터 타입(정수, 실수, 문자 등)을 결합할 때 자바는 자동으로 해당 데이터를 문자열로 변환하여 결합합니다.
```
String name = "John";
int age = 25;
String message = "My name is " + name + " and I am " + age + " years old.";
System.out.println(message); // 출력: My name is John and I am 25 years old.
```

즉, 문자열 + any type = 문자열

any type+문자열 = 문자열

문자열과 변수 결합: 변수의 값을 문자열과 결합할 수 있습니다.

int number = 42;
String text = "The number is " + number;
System.out.println(text); // 출력: The number is 42

Java와 spring boot 게시판 프로젝트 - 회원 가입 이메일 인증

Tue, 09 May 2023 12:55:14 GMT

회원가입 폼 만들기

회원가입을 위해 클라이언트 입장에서 정보를 입력할 폼이 필요하다.





    


    
        
        
            
                회원가입
                
                
                    Email
                    
                        
                            
                        
                        
                            
                        
                    
                    
                 
            
                
                
                    인증번호
                    
                        
                            
                        
                        
                            
                        
                    
                    
                        
                    
                    
                        Password
                        
                        
                        
                            Confirm Password
                            
                            
                        
                        
                            User name

사용자가 이메일을 입력하고 인증번호를 누르면 인증 메일이 발송되어 인증번호를 확인하여 가입이 가능 하도록했다.

이메일인증 코드 전송

Javascript

아래 코드는 이메일 인증 코드를 버튼을 클릭하면 컨트롤러로 이메일 값을 컨트롤러로 post형식으로 보내 컨트롤러는 사용자가 입력한 이메일을 받아 해당 이메일로 인증코드를 보내게된다.

/**
* 회원가입 조건 >
* 받아온 이메일이 DB에 이미 존재하는 이메일이면 안된다.
* 이메일 형식에 맞지 않으면 안된다.
* 입력한 비밀번호와 비밀번호 확인란에 기재한 문자는 같아야한다 .
* */


// 인증번호 발송
function sendEmail() {
  const email = $("#email").val(); // 사용자가 입력한 이메일 주소
  // 이메일칸이 비어있으면 알림
  if (!email || email.trim() === '') {
      alert("이메일 주소를 입력해주세요.");
      return;
  }

  $.ajax({
      url: "/infoCheck/sendEmail" ,// @PostMapping("/infoCheck/sendEmail") EmailController
      type: "POST",
      data: {
          "email": email
      },
      success: function(data) {
          // 이메일 전송 성공
          alert("인증번호가 전송되었습니다.");
      },
      error: function() {
          // 이메일 전송 실패
          alert("인증번호 전송에 실패했습니다.");
      }
  });
}

// 인증번호 확인
function verifyCode() {
  const inputCode = $("#inputCode").val(); // 사용자가 입력한 인증번호
  if (!inputCode || inputCode.trim() === '') { // 인증번호입력없이 확인하기를 눌렀을 경우 알림
    alert("인증번호를 입력해주세요.");
    return;
  }

  $.ajax({
    url: "/infoCheck/verifyCode",
    type: "POST",
    data: {
      "inputCode": inputCode
    },
    success: function(isCodeCorrect) {
      if (isCodeCorrect) {
        alert("인증번호가 일치합니다.");
      } else {
        alert("인증번호가 일치하지 않습니다.");
        $("#inputCode").focus();
      }
    },
    error: function() {
      alert("인증번호 확인에 실패했습니다.");
    }
  });
}

 //비밀번호 확인(span.innerHtml)
 function  chackPassword(){
       var password = $("#password");
       var confirmPassword = $("#confirmPassword");
       var confrimMsg = $("#confirmMsg");
       var correctColor = "green";    //맞았을 때 출력되는 색깔.
       var wrongColor ="red";    //틀렸을 때 출력되는 색깔
       if(password.value == confirmPassword.value){
           confirmMsg.style.color = correctColor;/* span 태그의 ID(confirmMsg) 사용  */
           confirmMsg.innerHTML ="비밀번호 일치";
       } else{
        confirmMsg.style.color = wrongColor;
        confirmMsg.innerHTML ="비밀번호 불일치";
       }
 }

    $(document).ready(function() {
        $('#password').on('keyup', function() {
            var password = $(this).val();
            var strength = '';
            if (password.length < 7) {
                strength = 'week';
                $('#password-strength').css('color', 'red');
            } else if (password.length >= 8) {
                strength = 'good!';
                $('#password-strength').css('color', 'green');
            }
            $('#password-strength').text(strength);
        });
    });


function SignUpFormSumitCheck(event) {
  // 폼 제출을 막기 위해 event.preventDefault() 호출
  event.preventDefault();

  // 입력된 이메일, 비밀번호, 비밀번호 확인 값을 가져옴
  const email = $("#email").val(); // 이메일
  const password = $("#password").val(); // 비밀번호
  const confirmPassword = $("#confirmPassword").val(); // 비밀번호 확인
  const inputCode = $("#inputCode").val(); // 인증번호 확인

  if (!isEmailValid(email)) {
    alert("올바른 이메일 형식이 아닙니다.");
    $("#email").focus();
    return;
  }


  // 인증번호 확인 AJAX 요청
  $.ajax({
    url: "/infoCheck/verifyCode",
    type: "POST",
    data: {
      "inputCode": inputCode
    },
    success: function(isCodeCorrect) {
      if (!isCodeCorrect) {
        alert("인증번호가 일치하지 않습니다.");
        return;
      }

      // 인증번호가 일치하면 회원가입 양식 확인 AJAX 요청
      const ajaxPromise = new Promise((resolve, reject) => {
        $.ajax({
          type: "post",
          url: "/SignUpForm/SignUpFormSumitCheck",
          data: {
            "email": email,
            "password": password,
            "confirmPassword": confirmPassword,
            "inputCode": inputCode,
          },
          success: function(res) {
            resolve(res);
          },
          error: function(err) {
            reject(err);
          }
        });
      });

      ajaxPromise.then((res) => {
        if (res == "Emailno") {
          alert("이메일을 확인해주세요.");
          document.getElementById("email").focus();

        } else if (res == "PWno") {
          alert("비밀번호를 확인해주세요.");
          document.getElementById("confirmPassword").focus();

        } else {
          alert("회원가입 성공.");
          console.log("res : ", res);
          document.getElementById("SignUpForm").submit();
        }
      }).catch((err) => {
        console.log("에러발생: ", err);
      });

    },
    error: function() {
      alert("인증번호 확인에 실패했습니다.");
    }
  });
}


// 이메일 형식 확인하는 함수
function isEmailValid(email) {
  const emailRegex = /^[\w-]+(\.[\w-]+)*@([\w-]+\.)+[a-zA-Z]{2,7}$/;
  return emailRegex.test(email);
}


function emailDuplicateCheck(){
     const email = $("#email").val();
     //       에 출력하기
     const checkResult = $("#checkResult");
     console.log("입력값 :" , email);

        // 형식
     if (!isEmailValid(email)) {
       console.log("올바른 이메일 형식이 아닙니다.");
       checkEmail.style.color = "red";
       checkEmail.innerHTML = "올바른 이메일 형식이 아닙니다.";
       return;
     }

     $.ajax({
         type:"post",
         url:"/SignUpForm/emailDuplicateCheck",
         data: {
             "email": email // "전송되는 파라미터 값 이름 ": 파라미터
         },
         success : function(res){
             console.log("요청성공 : ", res);
             if(res == "ok"){
                 console.log("사용가능한 이메일입니다.");
                 checkEmail.style.color = "green";
                 checkEmail.innerHTML="사용가능한 이메일입니다.";
             } else {
                 console.log("이미 사용중인 이메일입니다.");
                 checkEmail.style.color = "red";
                 checkEmail.innerHTML="이미 사용중인 이메일입니다.";
             }
         },
         error : function(err){
            console.log("에러발생: ",err);
            }

     })
}

Controller

package com.dandelion.dandelion.controller;

import com.dandelion.dandelion.service.EmailService;
import lombok.RequiredArgsConstructor;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;

import javax.servlet.http.HttpSession;

@Controller
@RequiredArgsConstructor // 생성자 주입 방식 사용
public class EmailController {
    private final EmailService emailService;

    @PostMapping("/infoCheck/sendEmail")
    public ResponseEntity sendEmail(@RequestParam("email") String email, HttpSession session) {
        // 이메일 전송 및 인증번호 저장
        String verificationCode = emailService.sendVerificationCode(email);
        session.setAttribute("verificationCode", verificationCode); // 세션에 전송된 인증번호를 저장.
        return ResponseEntity.ok().build();
    }

    //    입력한 인증번호와 세션에 저장된 인증번호를 비교
    @PostMapping("/infoCheck/verifyCode")
    public ResponseEntity verifyCode(@RequestParam("inputCode") String inputCode, HttpSession session) {
        String storedCode = (String) session.getAttribute("verificationCode");

        if (storedCode != null && storedCode.equals(inputCode)) {
            return ResponseEntity.ok(true);
        } else {
            return ResponseEntity.ok(false);
        }
    }
}

sendEmail 메서드는 이메일 주소를 받아 EmailService를 통해 인증번호를 전송한다. 전송된 인증번호는 사용자가 입력한 인증번호와 비교하기위해 세션에 저장된다.

verifyCode 메서드는 사용자가 입력한 인증번호와 세션에저장된 인증번호를 비교하는 메서드다. 일치하는 경우 true 불일치하는 경우 false 를 응답 본문에 담아 반환한다.

Service

package com.dandelion.dandelion.service;

import lombok.RequiredArgsConstructor;
import org.springframework.mail.SimpleMailMessage;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.stereotype.Service;

import java.security.SecureRandom;
import java.util.Random;


@RequiredArgsConstructor // 생성자 주입 사용하기
@Service
public class EmailService {

    private final JavaMailSender javaMailSender;

    public String sendVerificationCode(String recipient) {
        String verificationCode = generateEmailCode();
        String subject = "dandelion 인증번호";
        String message = "인증번호는 " + verificationCode + " 입니다.";

        sendEmail(recipient, subject, message);
        return verificationCode; // 세션에 저장하기위해 반환
    }

    public void sendEmail(String recipient, String subject, String text) {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setTo(recipient); // 수신자 설정
        message.setSubject(subject); // 제목 설정
        message.setText(text); // 내용 설정
        javaMailSender.send(message); // 메일 전송
    }

    /**
     * 이메일 인증번호를 생성하는 메서드
     *
     * @return 6자리 랜덤 알파벳 인증번호
     */
    public String generateEmailCode() {
        int codeLength = 6;  // 코드자리 6자리로 설정
        String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
        StringBuilder sb = new StringBuilder(codeLength);
        Random random = new SecureRandom();

        for (int i = 0; i < codeLength; i++) {
            int index = random.nextInt(alphabet.length());
            char randomChar = alphabet.charAt(index);
            sb.append(randomChar);
        }
        return sb.toString();
    }
}

sendVerificationCode 메서드는 수신자의 이메일 주소를 입력받아 인증번호를 생성하고 이메일을 전송한 후, 생성된 인증번호를 반환한다.

sendEmail 메서드는 수신자, 제목, 내용을 입력받아 이메일을 전송하는 역할을 한다. SimpleMailMessage 객체를 사용하여 메일을 구성하고 JavaMailSender를 사용하여 메일을 전송한다.

generateEmailCode 메서드는 6자리 랜덤 알파벳 인증번호를 생성하는 메서드다. SecureRandom을 사용해서 무작위 인덱스를 생성하고, 해당 인덱스에 있는 알파벳 문자를 결과문자열에 추가한다.

사용자는 인증번호를 입력하고 확인하기 버튼을 누른다

url: "/infoCheck/verifyCode",

버튼을 클릭하면 post형식으로 값이 컨트롤러로 넘어가면서 세션에 저장되어있는 값과 비교하여 인증 번호 일치 여부를 alert창으로 알린다.

action="/member/save"

회원가입 버튼을 누르면 form값이 위 주소로 넘어가기전에

onsubmit="SignUpFormSumitCheck(event)"

모든 회원가입 조건이 충족하는지 체크하고 회원가입이 진행된다.

-jascript 전체 코드 위에 참고-

member컨트롤러 회원정보 save하기

package com.dandelion.dandelion.controller;

import com.dandelion.dandelion.dto.MemberDTO;
import com.dandelion.dandelion.service.MemberService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpSession;

@RequiredArgsConstructor // 생성자 주입 사용하기

@Controller
public class MemberController {
    private final MemberService memberService;

    //    회원가입요청시 이메일 중복체크 비밀번호와 비밀번호 확인체크
    @PostMapping("/SignUpForm/SignUpFormSumitCheck")
    public @ResponseBody String SignUpFormSumitCheck(@RequestParam("email") String email, @RequestParam("password")
    String password, @RequestParam("confirmPassword")String confirmPassword){ // @ResponseBody ajax사용시 필요 어노테이션

        System.out.println("email = " + email);
        String checkresult = memberService.SignUpFormSumitCheck(email, password, confirmPassword);
        System.out.println(checkresult);

        return checkresult;

    }

    //    회원가입 이메일 입력시 innerhtml에 들어갈 메서드
    @PostMapping("/SignUpForm/emailDuplicateCheck")
    public @ResponseBody String emailDuplicateCheck(@RequestParam("email") String email){
        String emailChek = memberService.emailDuplicateCheck(email);
        return emailChek;

    }

    //  회원가입을 위한 메서드 입력받은 값을 userService에 넘긴다
    @PostMapping("/member/save") // 요청이 들어오면 메서드를 실행하겠다
    public String save(@ModelAttribute MemberDTO memberDTO){ // SignUpForm에서 입력받은 값의 name이 DTO의 멤버 명과 같을 때 세팅됨

        System.out.println("MemberController.save");
        System.out.println("memberDTO = " + memberDTO);
        memberService.save(memberDTO); // service객체에 dto객체를 넘김
        return "redirect:/member/loginForm";
    }
 }

컨트롤러로 넘어온 값은 @ModelAttribute을 사용해 MemberDTO 로 받고 memberService.save메서드를 호출하여 값을 저장한다

MemberService에서 회원정보 저장

@RequiredArgsConstructor // 생성자 주입 사용하기
@Service
public class MemberService {

    private final MemberRepository memberRepository;

    public void save(MemberDTO memberDTO) {
        //        1. dto -> entity 변환
        MemberEntity memberEntity = MemberEntity.toMemberEntity(memberDTO);
        //        2. repository의 save메서드 호출
        try {
            memberRepository.save(memberEntity); // jpa가 제공해주는 save 메서드
            System.out.println("회원테이블 DB저장시도");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

컨트롤러에서 넘어온 memberDTO 는 엔티티로 변환되어 MemberRepository의 save를 사용해 DB에 저장한다.

MemberRepository 인터페이스

package com.dandelion.dandelion.repository;

import com.dandelion.dandelion.entity.MemberEntity;
import org.springframework.data.jpa.repository.JpaRepository;

import java.util.Optional;

// JpaRepository 상속
public interface MemberRepository extends JpaRepository {
//    이메일로 회원정보 조회
    Optional findByEmail(String email);
}

MemberRepository 는 JPA에서 제공하는 JpaRepository를 확장하여 JpaRepository가 가지는 여러가지 기능을 상속받아 사용할 수 있다. 예를들면 찾기(find),삭제하기(delete),저장하기(save) 등이 있다.

Java와 spring boot 게시판 프로젝트 - 테이블 설계

Tue, 09 May 2023 09:46:15 GMT

테이블 설계

테이블 간 시간과 관련된 컬럼을 상속해 줄 BaseTime테이블
```
package com.dandelion.dandelion.entity;
```

import lombok.Getter; import org.hibernate.annotations.CreationTimestamp; import org.hibernate.annotations.UpdateTimestamp; import org.springframework.data.jpa.domain.support.AuditingEntityListener;

import javax.persistence.Column; import javax.persistence.EntityListeners; import javax.persistence.MappedSuperclass; import java.time.LocalDateTime;

@Getter @MappedSuperclass // 모든 JPA 엔티티들이 BaseTimeEntity를 상속 받을 경우 필드도 컬럼으로 인식하도록 한다. @EntityListeners(AuditingEntityListener.class) // BaseTimeEntity 클래스에 Auditing 기능을 포함시킨다. public class BaseTimeEntity {

@CreationTimestamp // 3
@Column(updatable = false)
private LocalDateTime localDateTime;

@UpdateTimestamp // 4
@Column(insertable = false)
private LocalDateTime modifiedDate;

}

회원테이블에는 회원가입 날짜와 회원정보 수정 일자가 필요했고, 게시글도 마찬가지였다.
그래서 이를 상속해줄 수 있는 클래스를 작성하여 시간 클래스를 상속받는 테이블들은 컬럼을 가지도록 코드를 작성했다. 





1. 회원정보를 담고있는 member테이블

```java
package com.dandelion.dandelion.entity;

import com.dandelion.dandelion.dto.MemberDTO;
import lombok.*;

import javax.persistence.*;
import java.util.ArrayList;
import java.util.List;

@Entity
@Getter
@Setter
@NoArgsConstructor // 기본 생성자가 생성
@AllArgsConstructor
@Table(name = "membertable") // db에 생성될 테이블 이름
public class MemberEntity extends BaseTimeEntity{ // BaseEntity를 상속
    @Id // pk
    @GeneratedValue(strategy = GenerationType.IDENTITY) // 시퀀스의 역할 auto_increment
    @Column(name="id" , nullable = false)
    private Long id; // 회원번호아이디
    @Column(name ="email",nullable = false , unique = true ,length = 50)
    private String email; // 회원이메일
    @Column(name ="password",nullable = false,length = 100)
    private String password; // 회원비밀번호
    @Column(name ="name",nullable = false,length = 50)
    private String name; // 회원이름
    @Column(name ="role",nullable = false)
    private String role = "user"; // 역할 디폴트 user

    @OneToMany(mappedBy = "member" , cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    private List boards = new ArrayList<>();
    @OneToMany(mappedBy = "member" , cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    private List comments = new ArrayList<>();

    public static MemberEntity toMemberEntity(MemberDTO memberDTO){
        MemberEntity memberEntity = new MemberEntity();
        /*DTO에 감긴 값을 Entity로 세팅하는 과정*/
        memberEntity.setId(memberDTO.getId());
        memberEntity.setName(memberDTO.getName());
        memberEntity.setEmail(memberDTO.getEmail());
        memberEntity.setPassword(memberDTO.getPassword());
        memberEntity.setRole(memberDTO.getRole() == null ? "user" : memberDTO.getRole());
        return memberEntity;
    }
}

회원과 게시글의 관계를 설명하자면, 한 명의 회원은 여러 개의 게시글을 작성할 수도 있다 댓글도 마찬가지로, 한 명의 회원은 여러 개의 댓글을 작성할 수 있다

따라서 @OneToMany로 테이블 간의 관계를 설정해주었다.

2. 게시글의 정보를 가지고있는 Board테이블

package com.dandelion.dandelion.entity;

import com.dandelion.dandelion.dto.BoardDTO;
import com.dandelion.dandelion.repository.MemberRepository;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

import javax.persistence.*;
import java.util.ArrayList;
import java.util.List;

@Entity
@Getter
@Setter
@NoArgsConstructor // 기본 생성자가 생성
@AllArgsConstructor
@Table(name = "baordtable") // db에 생성될 테이블 이름
public class BoardEntity extends BaseTimeEntity{
    @Id // pk
    @GeneratedValue(strategy = GenerationType.IDENTITY) // 시퀀스의 역할 auto_increment
    @Column(name="id" , nullable = false)
    private Long id; // 게시글 넘버
    @Column(name="title" , nullable = false,length = 100)
    private String title; // 제목
    @Column(name="content" , nullable = false)
    private String content; // 내용
    @Column(name="categories" , nullable = false)
    private String categories; // 카테고리

    @ManyToOne
    @JoinColumn(name = "member_id")
    private MemberEntity member;
    @OneToMany(mappedBy = "board" , cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    private List comments = new ArrayList<>();


    public static BoardEntity toBoardEntity(BoardDTO boardDTO, MemberEntity member) {
        BoardEntity boardEntity = new BoardEntity();
        boardEntity.setId(boardDTO.getId());
        boardEntity.setCategories(boardDTO.getCategories());
        boardEntity.setTitle(boardDTO.getTitle());
        boardEntity.setContent(boardDTO.getContent());
        boardEntity.setMember(member);
        return boardEntity;
    }

    public String getMemberName() {
        return member != null ? member.getName() : "";
    }

}

게시글은 한 명의 회원의 정보만을 가질 수 있으며, 반대로 댓글은 여러개가 하나의 게시글에 연결되기 때문에 게시글과 회원테이블간의 관계는 @ManyToOne로 게시글과 댓글의 관계는 @OneToMany 로 작성했다.

댓글의 정보를 가지고있는 comment 테이블

package com.dandelion.dandelion.entity;

import com.dandelion.dandelion.dto.CommentsDTO;
import com.dandelion.dandelion.repository.BoardRepository;
import com.dandelion.dandelion.repository.MemberRepository;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

import javax.persistence.*;
import java.util.Optional;

@Entity
@Getter
@Setter
@NoArgsConstructor // 기본 생성자가 생성
@AllArgsConstructor
@Table(name = "conmmentstable") // db에 생성될 테이블 이름
public class CommentsEntity extends BaseTimeEntity{
        @Id // pk
        @GeneratedValue(strategy = GenerationType.IDENTITY) // 시퀀스의 역할 auto_increment
        @Column(name="id" , nullable = false)
        private Long id; // 댓글 고유번호
        @Column(name="title" , nullable = false,length = 100)
        private String content; // 내용

        @ManyToOne
        @JoinColumn(name = "member_id")
        private MemberEntity member;
        @ManyToOne
        @JoinColumn(name = "board_id")
        private BoardEntity board;

        public static CommentsEntity toCommentsEntity(CommentsDTO commentsDTO, MemberRepository memberRepository, BoardRepository boardRepository) {
                CommentsEntity commentsEntity = new CommentsEntity();
                commentsEntity.setId(commentsDTO.getId());
                commentsEntity.setContent(commentsDTO.getContent());

                if (commentsDTO.getMemberId() != null) {
                        Optional memberOpt = memberRepository.findById(commentsDTO.getMemberId());
                        memberOpt.ifPresent(commentsEntity::setMember);
                }

                if (commentsDTO.getBoardId() != null) {
                        Optional boardOpt = boardRepository.findById(commentsDTO.getBoardId());
                        boardOpt.ifPresent(commentsEntity::setBoard);
                }

                return commentsEntity;
        }

}

댓글은 한명의 회원 그리고 하나의 게시글에만 작성되기때문에 둘다 @ManyToOne 으로 테이블관계를 설정해주면 된다.

Java - literal의 타입, 접두사와 접미사 내용 정리

Tue, 09 May 2023 07:53:39 GMT

literal의 타입, 접두사와 접미사

리터럴의 타입은 저장되는 값의 데이터 타입에 따라 결정됩니다. 자바에서는 정수, 부동소수점, 문자,문자열,불리언 등의 리터럴 타입이 있습니다.

리터럴 값은 접두사(prefix)와 접미사(suffix)를 사용하여 표현할 수 있습니다.
이를 통해 리터럴 값의 데이터 타입이나 진법을 명시적으로 지정할 수 있습니다.

정수 리터럴

10진수 - 기본적으로 정수 리터럴은 10진수로 표현됩니다. 접두사나 접미사가 없습니다.

int decimal = 42;

2진수 - 접두사 0b 또는 0B를 사용하여 2진수 정수 리터럴을 표현합니다.

int binary = 0b101010;

8진수 - 접두사 0를 사용하여 8진수 리터럴을 표현합니다.

int octal = 052;

16진수 - 접두사 0x 또는 0X를 사용하여 16진수 정수 리터럴을 표현합니다.

int hexadecimal = 0x2A;

부동소수점 리터럴

실수 리터럴 - 기본적으로 부동소수점 리터럴은 실수로 표현됩니다. 접미사가 없으면 기본적으로 double 타입으로 간주됩니다.

double real = 3.14159;

float 타입 - 접미사 f 또는 F를 사용하여 float 타입의 부동소수점 리터럴을 표현합니다.

float floatValue = 3.14F;

double 타입 - 접미사 d 또는 D를 사용하여 double 타입의 부동소수점 리터럴을 명시적으로 표현할 수 있습니다.

double doubleValue = 3.14159D;

문자 리터럴

문자 리터럴은 작은따옴표 ''로 묶인 단일 문자를 사용하여 표현합니다.

char letter = 'A';

문자열 리터럴

문자열 리터럴은 큰따옴표 ""로 묶인 문자들의 시퀀스를 사용하여 표현합니다.

String name = "choigoyo";

불리언 리터럴

불리언 리터럴은 true 와 false값을 사용하여 표현합니다.

boolean isActive = true;

Java - 변수와 상수 리터럴 개념 정리

Tue, 09 May 2023 07:24:50 GMT

변수와 상수, 그리고 리터럴

변수(variable)

값이 변할 수 있는 메모리 공간을 나타내며, 프로그램 실행 중에 값이 변경될 수 있습니다.

int number = 10;
number = 20;

여기에서 number는 변수이며, 값을 변경할 수 있습니다.

상수(constant)

값이 변하지 않는 메모리 공간을 나타내며, 프로그램 실행 중에 값이 변경되지 않습니다.
상수는 일반적으로 대문자와 밑줄(_)로 구성된 이름을 사용하여 선언하며, final 키워드를 사용하여 선언합니다.

final double PI = 3.14159;

여기에서 PI는 상수이며, 값을 변경할 수 없습니다.

리터럴(literal)은 소스 코드에서 직접 사용되는 고정된 값입니다.
리터럴은 변수나 상수에 할당될 수 있습니다.

리터럴(literal)

소스 코드에서 직접 사용되는 고정된 값입니다.
리터럴은 변수나 상수에 할당될 수 있습니다.

int number = 42;         // 42는 정수형 리터럴입니다.
double price = 9.99;     // 9.99는 부동소수점 리터럴입니다.
char letter = 'A';       // 'A'는 문자 리터럴입니다.
String name = "John";    // "John"은 문자열 리터럴입니다.
boolean isActive = true; // true는 불리언 리터럴입니다.

이 예시에서 42, 9.99, 'A', "John" 및 true는 각각 정수, 부동소수점, 문자, 문자열 및 불리언 리터럴입니다.
이러한 리터럴은 코드에서 직접 사용되며, 변수나 상수에 할당할 수 있습니다.

Java - 변수 타입

Mon, 08 May 2023 18:16:55 GMT

변수의 타입

자바에서 변수의 타입은 기본 데이터 타입과 참조 데이터 타입으로 구분됩니다.

기본 데이터 타입 : 기본 데이터 타입은 단순한 값을 저장하는 변수 타입으로, 메모리에 직접 값을 저장합니다.

자바에서는 다음과 같은 기본 데이터 타입이 있습니다.

정수형 : 정수값을 저장할 수 있는 타입으로, byte, short, int, long이 있습니다. 각각의 크기와 값의 범위가 다릅니다.
- byte: 8비트, -128 ~ 127 범위의 정수
- short: 16비트, -32,768 ~ 32,767 범위의 정수
- int: 32비트, -2,147,483,648 ~ 2,147,483,647 범위의 정수
- long: 64비트, -9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807 범위의 정수
실수형 : 부동소수점 값을 저장할 수 있는 타입으로, float와 double이 있습니다.
- float : 32비트, 대략 ±3.4 x 10^38 범위의 실수
- double : 64비트, 대략 ±1.8 x 10^308 범위의 실수
문자형 : 문자 값을 저장할 수 있는 타입으로, char가 있습니다.
- char: 16비트, 0 ~ 65,535 범위의 유니코드 문자
논리형 : 참(true) 또는 거짓(false) 값을 저장할 수 있는 타입으로, boolean이 있습니다. boolean: true 또는 false

참조 데이터 타입 : 참조 데이터 타입은 객체의 참조(주소)를 저장하는 변수 타입입니다. 참조 데이터 타입에는 클래스, 인터페이스, 배열이 있습니다. 참조 데이터 타입 변수는 힙(heap) 메모리에 생성된 객체를 참조합니다.

클래스 : 사용자 정의 클래스 또는 자바에서 제공하는 클래스를 사용하여 변수를 선언할 수 있습니다. 예를 들어, String 클래스를 사용하는 변수는 참조 데이터 타입입니다.
인터페이스 : 인터페이스 타입의 변수는 해당 인터페이스를 구현한 클래스의 인스턴스를 참조할 수 있습니다.
배열 : 배열은 동일한 타입의 여러 개의 값을 저장할 수 있는 참조 데이터 타입입니다. 배열은 기본 데이터 타입이나 참조 데이터 타입을 요소로 가질 수 있습니다.

Java - 변수 variable

Mon, 08 May 2023 17:40:11 GMT

변수(variable) 란 ?

프로그래밍 언어에서 값을 저장하고 참조하기 위한 메모리 공간에 대한 이름입니다. 자바에서수는 데이터 타입(data type)과 이름(identifier)을 사용하여 선언하며, 값을 저장하거나 추출할 때 변수 이름을 사용합니다.

int number;

여기서 int는 데이터 타입이며, number는 변수의 이름입니다. 이제 number라는 이름으로 해당 변수에 값을 저장하거나 추출할 수 있습니다.

변수에 값을 할당하려면 다음과 같이 작성합니다.

int anotherNumber = number + 5;

anotherNumber 변수에는 number 변수의 값(10)에 5를 더한 결과인 15가 저장됩니다.

= 기호는 등호가 아니라 대입의 의미를 가지고있습니다.

자바에서는 대입 연산자라고 부릅니다.

변수의 초기화

변수 초기화란 변수에 처음 값을 할당하는 과정입니다.

프로그램에서 변수를 사용하기 전에 변수를 초기화해야 합니다.

초기화되지 않은 변수는 메모리에 존재하는 기존의 쓰레기 값이나 불확실한 값이 할당되어 있을 수 있으며, 이로 인해 예기치 않은 결과가 발생할 수 있습니다.

변수를 선언하면서 동시에 초기화하는 방법을 사용할 수 있습니다.

예를 들어, 다음과 같이 변수를 선언하면서 초기화할 수 있습니다.

int number = 10; // 'number' 변수를 선언하고 10으로 초기화

또는 먼저 변수를 선언한 후 별도의 문장에서 초기화할 수도 있습니다:

int number; // 'number' 변수를 선언
number = 10; // 'number' 변수를 10으로 초기화

클래스 내의 인스턴스 변수와 정적 변수는 자동으로 기본 값으로 초기화됩니다.

기본값은 데이터 타입에 따라 달라집니다.

예를 들어, 정수형 변수의 기본값은 0이고, 부동소수점형 변수의 기본값은 0.0입니다. 불리언 변수의 기본값은 false이고, 참조형 변수의 기본값은 null입니다.

로컬 변수(메소드 내에서 선언된 변수)는 자동으로 초기화되지 않습니다.

로컬 변수를 사용하기 전에 명시적으로 초기화해야 합니다.

그렇지 않으면 컴파일러는 초기화되지 않은 변수 사용에 대한 오류 메시지를 표시합니다.

변수의 세가지 유형

자바에서 변수는 클래스 변수, 인스턴스 변수, 그리고 지역 변수로 구분됩니다.
이 세 가지 변수 유형은 선언 위치, 사용 범위, 그리고 생명 주기에 따라 차이가 있습니다.

클래스 변수 (static 변수): 클래스 변수는 클래스 내에서 static 키워드를 사용해 선언되며, 해당 클래스의 모든 인스턴스에서 공유됩니다. 클래스 변수는 클래스가 로드될 때 생성되고, 클래스가 언로드될 때 소멸합니다. 클래스 변수는 메모리에서 한 번만 할당되므로, 모든 객체가 동일한 메모리 공간에 접근합니다.

class MyClass {
    static int classVar; // 클래스 변수
}

인스턴스 변수: 인스턴스 변수는 클래스 내에서 선언되지만, static 키워드를 사용하지 않습니다. 인스턴스 변수는 각 객체마다 별도로 할당되며, 객체가 생성될 때 생성되고 객체가 소멸될 때 소멸합니다. 인스턴스 변수는 객체마다 각각의 메모리 공간을 가집니다.
```
class MyClass {
int instanceVar; // 인스턴스 변수
}
```
지역 변수: 지역 변수는 메소드 또는 블록 내에서 선언되며, 선언된 메소드나 블록 내에서만 사용할 수 있습니다. 지역 변수는 메소드 호출 시 생성되고, 메소드가 종료될 때 소멸합니다. 지역 변수는 메소드 호출 시마다 새로운 메모리 공간을 할당받습니다.
```
void myMethod() {
 int localVar; // 지역 변수
}
```

지역 변수와 인스턴스 변수의 주요 차이점은 다음과 같습니다.

선언위치 : 지역변수는 메소드나 블록 내에서 선언되지만, 인스턴스 변수는 클래스 내에서 선언됩니다.
사용범위 : 지역변수는 선언된 메소드나 블록 내에서만 사용할 수 있습니다. 인스턴스 변수는 클래스 내의 모든 메소드에서 사용할 수 있습니다.
생명주기 : 지역 변수는 메소드 호출시 생성되고 메소드가 종료될 때 소멸합니다. 인스턴스 변수는 객체가 생성될때 생성되고 객체가 소멸될때 소멸합니다.
메모리할당 : 지역 변수는 스택 메모리에 할당되며, 인스턴스 변수는 힙 메모리에 할당됩니다. 이러한 차이점을 이해하면 변수의 사용범위와 생명주기를 적절하게 관리할 수 있습니다.

JWT - 인증이 필요한 페이지 요청시 토큰으로 권한 인증

Wed, 03 May 2023 16:59:15 GMT

인증된 사용자에게 토큰을 담은 응답하기

package com.choigoyo.config.JWT;

import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import com.choigoyo.config.auth.PrincipalDetails;
import com.choigoyo.entity.UserEntityJWT;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.RequiredArgsConstructor;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Date;

@RequiredArgsConstructor
public class JwtAuthenticationFilter extends UsernamePasswordAuthenticationFilter {
    /**
     * Spring Security 의 UsernamePasswordAuthenticationFilter 를 확장하여 사용하게되면
     * http://localhost:8081/login 주소로 userName,password 를 post 형식으로 전송하면
     * UsernamePasswordAuthenticationFilter 가 동작함 SecurityConFig 클래스에 form 로그인을 비활성화 시켜서 동작하지 않는 상태이나,
     * JwtAuthenticationFilter 를 다시 SecurityConFig 클래스에 등록해주면 동작하게됨
     */

    private final AuthenticationManager authenticationManager;


    // http://localhost:8081/login 요청이 들어오면 authenticationManager 통해서 로그인시도
    @Override
    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {
        System.out.println("JwtAuthenticationFilter : 로그인 시도중...");

        // 1 사용자의 userName, password 를 받는다
        // 2 로그인이 가능한지 확인
        // 3 PrincipalDetails 를 세션에 담는다 (권한 관리를 위해)
        // 4 JWT 토큰을 만들어서 응답해준다

        try {
            // request.getInputStream() 에 담겨있는 값 확인하기
//            BufferedReader reader = request.getReader();
//            String input = null;
//            while ((input = reader.readLine())!= null) {
//                System.out.println(input); // 보내온 값을 한줄씩 출력


            // json 데이터를 파싱해줌
            ObjectMapper objectMapper = new ObjectMapper();
            UserEntityJWT userEntityJWT = objectMapper.readValue(request.getInputStream(), UserEntityJWT.class);
            // 유저에 정보가 잘 담겼는지 print 해보기
            System.out.println(userEntityJWT);
            // 토큰 생성(userName, password 를 담은)
            UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken =
                    new UsernamePasswordAuthenticationToken(userEntityJWT.getUserName(),userEntityJWT.getPassword());
            // authenticationManager.authenticate() 인증 수행하기
            // 그리고 PrincipalDetailsService 의 loadByUsername() 함수가 실행됨
            Authentication authenticate = authenticationManager.authenticate(usernamePasswordAuthenticationToken);
            System.out.println(request.getInputStream()); // request.getInputStream() 은 HttpServletRequest 객체로부터 입력 스트림을 가져오는 데 사용
            // 클라이언트 또는 다른 웹브라우저에서 서버로 전송된 데이터를 읽는데 사용할 수 있는 InputStream 객체
            // authenticate 객체가 session 영역에 저장됨
            PrincipalDetails principalDetails = (PrincipalDetails)authenticate.getPrincipal();
            System.out.println("==================로그인 완료=================="); // 구분선
            System.out.println("principalDetails userName :"+principalDetails.getUser().getUserName());
            System.out.println("==============================================="); // 구분선
            return authenticate;
        } catch (Exception ex) {
            ex.printStackTrace();
            return null;
        }
    }

    // 순서 ->  attemptAuthentication 에서 인증이 정상적으로 실행되고 successfulAuthentication 메서드 실행
    // JWT 토큰을 만들어서 request 요청한 사용자에게 토큰을 응답과함께 전달
    @Override
    protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication authResult) throws IOException, ServletException {
        System.out.println("사용자 인증이 완료되어 successfulAuthentication 메서드가 실행됩니다.");

        PrincipalDetails principalDetails = (PrincipalDetails)authResult.getPrincipal();

        // 빌드패턴으로 토큰 생성하기
        String jwtToken = JWT.create()
                .withSubject("JWT-TOKEN")
                .withExpiresAt(new Date(System.currentTimeMillis() + (60000 * 10))) // 토큰의 유효시간을 10분으로 지정
                .withClaim("id", principalDetails.getUser().getId())
                .withClaim("username", principalDetails.getUser().getUserName())
                .sign(Algorithm.HMAC512("server-secret")); // server만 알고있는 secret값 으로 서명

        response.addHeader("Authentication","Bearer "+jwtToken);  // 사용자에게 응답

        System.out.println("==================토큰 생성==================");
        System.out.println("name : Authentication");
        System.out.println("value: Bearer "+ jwtToken);

    }
}

클라이언트가 로그인 요청을하고 인증단계에 들어갑니다. 인증이 완료가되면 successfulAuthentication 메서드가 실행되며 토큰을 만들어 클라이언트에게 응답합니다. (응답 Header의 Authentication 객체 안에는 토큰이 들어있습니다.)

postman으로 클라이언트의 아이디와 비밀번호 정보를 json으로 입력해주고 post 타입이르 로그인 요청을 보내면, JwtAuthenticationFilter 클래스의 attemptAuthentication 메서드가 실행되면 데이터를 파싱하고 유저정보를 가지고 인증을 수행합니다.

인증이 완료되고나서 successfulAuthentication 메서드에서 토큰을 생성해 응답 Header의Authentication 객체에 토큰을 담아 응답합니다.

권한이 필요한 페이지를 요청했을 때

package com.choigoyo.config.JWT;

import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import com.choigoyo.config.auth.PrincipalDetails;
import com.choigoyo.entity.UserEntityJWT;
import com.choigoyo.repository.UserRepository;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.authentication.www.BasicAuthenticationFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;


public class JwtAuthorizationFilter extends BasicAuthenticationFilter {
    // BasicAuthenticationFilter Spring Security에서 제공하는 필터 중 하나로, HTTP 요청이 들어올 때 기본 인증(Basic Authentication)을 처리하는 역할
    // 인증이나 권한이 필요한 주소요청이 있을 때 해당 필터를 거치게됨
    private UserRepository userRepository;

    public JwtAuthorizationFilter(AuthenticationManager authenticationManager, UserRepository userRepository) {
        super(authenticationManager);
        this.userRepository = userRepository;
    }

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException {
        System.out.println("인증이나 권한이 필요한 주소가 요청되었습니다.");
        String jwtHeader = request.getHeader("Authorization"); // header 값을 확인해서 출력해보기
        System.out.println("jwtHeader : "+jwtHeader);
        // JWT 토큰을 검증해서 정상적인 사용자인지 확인
        if (jwtHeader == null || !jwtHeader.startsWith("Bearer ")) { // header에 토큰이 존재하지 않거나 토큰의 시작이 Bearer이 아니라면
            chain.doFilter(request,response); // 다시 필터를 거치게
            return;
        }

        // Authorization 에서 토큰값만 저장하기위해  "Bearer "을 빈 문자열로 변경하여 저장 (토큰값만 뽑아내는 작업)
        String jwtToken = request.getHeader("Authorization").replace("Bearer ", "");
        // 서명하여 user의 이름을 가져온다.
        String userName = JWT.require(Algorithm.HMAC512("server-secret")).build().verify(jwtToken)
                .getClaim("username").asString();
        System.out.println("================ username ==================");
        System.out.println("userName : "+userName);
        // 서명이 정상적으로 되면 if문 실행
        if (userName != null) {
            UserEntityJWT userEntityJWT = userRepository.findByUserName(userName);
            System.out.println("=================== 토큰으로 사용자 정보 찾기 ===================");
            System.out.println("userEntityJWT : "+userEntityJWT);
            PrincipalDetails principalDetails = new PrincipalDetails(userEntityJWT);

            Authentication authentication =
                    new UsernamePasswordAuthenticationToken(
                            principalDetails, //나중에 컨트롤러에서 DI해서 쓸 때 사용하기 편함.
                            null, // 패스워드는 모르니까 null 처리
                            principalDetails.getAuthorities());

            // 강제로 세션공간에 접근하여 Authentication 객체를 세션 영역에 저장
            SecurityContextHolder.getContext().setAuthentication(authentication);
            chain.doFilter(request,response); // 다시 필터를 거치게
        }

    }
}

JwtAuthorizationFilter 클래스는 권한이 필요한 페이지에 대한 요청이 발생할 때 호출되며, 사용자가 제공한 JWT 토큰을 검증합니다. 검증이 완료되면 토큰에서 사용자 이름을 추출하고, 이를 사용하여 데이터베이스에서 사용자 정보를 가져옵니다.

PrincipalDetails 객체를 생성한 후, UsernamePasswordAuthenticationToken 객체를 생성하여 사용자 정보와 권한을 설정합니다. 이후, SecurityContextHolder를 사용하여 인증 객체를 세션에 저장하고, 필터 체인을 계속 실행하여 요청을 처리합니다.

요약하면, 이 클래스는 다음과 같은 작업을 수행합니다:

요청 헤더에서 JWT 토큰을 검색합니다.
토큰이 올바른지 검증하고, 사용자 이름을 추출합니다.
사용자 이름을 기반으로 데이터베이스에서 사용자 정보를 가져옵니다.
사용자 정보와 권한을 포함하는 UsernamePasswordAuthenticationToken 객체를 생성합니다.
SecurityContextHolder를 사용하여 인증 객체를 세션에 저장합니다.
필터 체인을 계속 실행하여 요청을 처리합니다.

이 프로세스는 권한이 필요한 페이지에 대한 요청을 처리하는 데 사용되며, 올바른 사용자 인증을 보장합니다.

JWT - 사용자 로그인 요청시 토큰을 생성하여 응답하기

Wed, 03 May 2023 07:39:42 GMT

JwtAuthenticationFilter 의 successfulAuthentication 메서드

    // 순서 ->  attemptAuthentication 에서 인증이 정상적으로 실행되고 successfulAuthentication 메서드 실행
    // JWT 토큰을 만들어서 request 요청한 사용자에게 토큰을 응답과함께 전달
    @Override
    protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication authResult) throws IOException, ServletException {
        System.out.println("사용자 인증이 완료되어 successfulAuthentication 메서드가 실행됩니다.");

        PrincipalDetails principalDetails = (PrincipalDetails)authResult.getPrincipal();

        // 빌드패턴으로 토큰 생성하기
        String jwtToken = JWT.create()
                .withSubject(principalDetails.getUsername()+"님의 토큰")
                .withExpiresAt(new Date(System.currentTimeMillis()+(6000*10))) // 토큰의 유효시간 10분으로 지정
                .withClaim("id", principalDetails.getUser().getId())
                .withClaim("username", principalDetails.getUser().getUserName())
                .sign(Algorithm.HMAC512("server-secret")); // server만 알고있는 secret값 으로 서명

        response.addHeader("Authentication","Bearer "+jwtToken);  // 사용자에게 응답
        System.out.println("==================토큰 생성==================");
        System.out.println("name : Authentication");
        System.out.println("value: Bearer "+ jwtToken);

    }

사용자 인증이 성공적으로 완료된 후 실행되는 successfulAuthentication 메서드입니다. 이 메서드의 주요 목적은 인증된 사용자에게 JWT 토큰을 생성하고 응답과 함께 전달하는 것입니다. 코드 설명은 다음과 같이 진행할 수 있습니다.

successfulAuthentication 메서드는 인증이 성공한 후 호출됩니다.
인증 결과(authResult)에서 PrincipalDetails 객체를 가져옵니다. 이 객체는 인증된 사용자의 정보를 포함하고 있습니다.
JWT 토큰을 생성하기 위해 JWT.create()를 호출하고, 이어서 다음 작업을 수행합니다:

사용자 이름을 서브젝트로 설정합니다.
토큰의 만료 시간을 현재 시간으로부터 10분 후로 설정합니다.
사용자의 ID와 사용자 이름을 클레임으로 추가합니다.
서버의 비밀 키("server-secret")를 사용하여 토큰을 서명합니다.

생성된 JWT 토큰을 응답 헤더에 추가합니다. 헤더 이름은 "Authentication"이고, 값은 "Bearer " + jwtToken입니다.

postman으로 로그인 완료시 클라이언트에게 토큰과함께 응답하는지 확인하기

json 방식으로 로그인 요청을 했을 때 정상적으로 사용자 인증이되면 successfulAuthentication 메서드에서 토큰을 만들어 응답 헤더에 토큰값을 넣어줍니다.

Authentication 의 value값으로 토큰이 잘 들어간 것을 확인할 수 있습니다.

JWT - json 로그인 요청에 대한 파싱과 사용자 인증 테스트

Tue, 02 May 2023 17:39:50 GMT

postman 로그인 테스트 - x-www-form-urlencoded 회원정보 send

사용자가 로그인시도를 할 때 요청 본문의 데이터를 한 줄씩 읽어 출력해 봤습니다.

postman 로그인 테스트 - json 회원정보 send

각 다른식으로 출력되는 것을 확인할 수 있었습니다.

클라이언트로부터 전송된 데이터를 적절하게 처리하고 분석하기 위해 파싱을 사용해 인증을 수행해야합니다.

파싱을 사용하는 이유는 클라이언트로부터 전송된 데이터 요청에 필요한 인증정보를 추출하고 이를 사용하여 인증을 수행하기 위함입니다.

json 으로 넘어온 값을 파싱하기

package com.choigoyo.config.JWT;

import com.choigoyo.config.auth.PrincipalDetails;
import com.choigoyo.entity.UserEntityJWT;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.RequiredArgsConstructor;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@RequiredArgsConstructor
public class JwtAuthenticationFilter extends UsernamePasswordAuthenticationFilter {
    /**
     * Spring Security 의 UsernamePasswordAuthenticationFilter 를 확장하여 사용하게되면
     * http://localhost:8081/login 주소로 userName,password 를 post 형식으로 전송하면
     * UsernamePasswordAuthenticationFilter 가 동작함 SecurityConFig 클래스에 form 로그인을 비활성화 시켜서 동작하지 않는 상태이나,
     * JwtAuthenticationFilter 를 다시 SecurityConFig 클래스에 등록해주면 동작하게됨
     */

    private final AuthenticationManager authenticationManager;


    // http://localhost:8081/login 요청이 들어오면 authenticationManager 통해서 로그인시도
    @Override
    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {
        System.out.println("JwtAuthenticationFilter : 로그인 시도중...");

        // 1 사용자의 userName, password 를 받는다
        try {
            // json 데이터를 파싱해줌
            ObjectMapper objectMapper = new ObjectMapper();
            UserEntityJWT userEntityJWT = objectMapper.readValue(request.getInputStream(), UserEntityJWT.class);
            // 유저에 정보가 잘 담겼는지 print 해보기
            System.out.println(userEntityJWT);
            // 토큰 생성(userName, password 를 담은)
            UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken =
                    new UsernamePasswordAuthenticationToken(userEntityJWT.getUserName(),userEntityJWT.getPassword());
            // authenticationManager.authenticate() 인증 수행하기
            // 그리고 PrincipalDetailsService 의 loadByUsername() 함수가 실행됨
            Authentication authenticate = authenticationManager.authenticate(usernamePasswordAuthenticationToken);
            System.out.println(request.getInputStream()); // request.getInputStream() 은 HttpServletRequest 객체로부터 입력 스트림을 가져오는 데 사용
            // 클라이언트 또는 다른 웹브라우저에서 서버로 전송된 데이터를 읽는데 사용할 수 있는 InputStream 객체
            // authenticate 객체가 session 영역에 저장됨
            PrincipalDetails principalDetails = (PrincipalDetails)authenticate.getPrincipal();
            System.out.println("==================로그인 완료=================="); // 구분선
            System.out.println("principalDetails userName :"+principalDetails.getUsername());
            System.out.println("==============================================="); // 구분선
            return authenticate;
        } catch (Exception ex) {
            ex.printStackTrace();
            return null;
        }
    }

    // 순서 ->  attemptAuthentication 에서 인증이 정상적으로 실행되고 successfulAuthentication 메서드 실행
    // JWT 토큰을 만들어서 request 요청한 사용자에게 토큰을 응답과함께 전달
    @Override
    protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication authResult) throws IOException, ServletException {
        System.out.println("사용자 인증이 완료되어 successfulAuthentication 메서드가 실행됩니다.");
        super.successfulAuthentication(request, response, chain, authResult);
    }

}

객체에 잘 담겨 출력되었습니다. 이 값으로 로그인 시도를 하기위해 토큰을 만들어야합니다. ( formlogin을 비활성화해서 직접 만들어야합니다. )

코드를 순서대로 설명하자면 아래와 같습니다.

ObjectMapper 객체를 생성합니다. ObjectMapper는 Jackson 라이브러리에서 제공하는 클래스로, JSON 데이터를 Java 객체로 변환하거나 Java 객체를 JSON으로 변환할 때 사용합니다.
request.getInputStream()을 사용하여 UserEntityJWT 객체를 생성합니다. ObjectMapper의 readValue() 메소드를 사용하여 요청 본문의 JSON 데이터를 UserEntityJWT 클래스의 객체로 변환합니다. 이 작업을 통해 사용자가 제공한 userName과 password 정보가 userEntityJWT 객체에 저장됩니다.
System.out.println(userEntityJWT)를 호출하여 변환된 userEntityJWT 객체의 내용을 출력합니다. 이를 통해 요청 본문의 데이터가 제대로 변환되었는지 확인할 수 있습니다.
UsernamePasswordAuthenticationToken 객체를 생성합니다. UserEntityJWT 객체에서 userName과 password 정보를 가져와 UsernamePasswordAuthenticationToken 객체를 생성합니다. 이 토큰은 인증 프로세스에서 사용됩니다.
authenticationManager.authenticate() 메소드를 호출하여 인증을 수행합니다. 생성된 UsernamePasswordAuthenticationToken 객체를 사용하여 authenticationManager의 authenticate() 메소드를 호출합니다. 이 때 PrincipalDetailsService의 loadByUsername() 메소드가 실행되며, 인증이 성공적으로 수행되면 Authentication 객체를 반환합니다.
request.getInputStream()을 출력합니다. 마지막으로 System.out.println(request.getInputStream())를 호출하여 InputStream 객체를 출력합니다.

attemptAuthentication 사용자 인증이 완료되면, successfulAuthentication 메서드가 실행됩니다.

정상적으로 메서드가 동작하는지 테스트하기위해 print문으로 출력해보겠습니다.

JWT - 회원가입 로직 작성하기

Tue, 02 May 2023 13:09:59 GMT

로그인을 학습하기 전 회원가입 로직을 간단하게 만들었습니다. 먼저, 회원가입시 입력한 비밀번호를 암호화 하기위해 BCryptPasswordEncoder 를 추가해줍니다.

JwtApplication

package com.choigoyo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

@SpringBootApplication
public class JwtApplication {

    @Bean
    public BCryptPasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
    public static void main(String[] args) {
        SpringApplication.run(JwtApplication.class, args);
    }

}

RestApiController

회원정보를 DB에 저장하기위해 UserRepository를 @Autowired 하고, 비밀번호를 DB에 저장시 보안을 위해 BCryptPasswordEncoder 를 @Autowired 합니다.

/join 요청이 들어왔을 때 처리를 위해 PostMapping타입으로 컨트롤러를 간단하게 합니다.

package com.choigoyo.controller;

import com.choigoyo.entity.UserEntityJWT;
import com.choigoyo.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class RestApiController {

    @Autowired
    private UserRepository userRepository;
    @Autowired
    private BCryptPasswordEncoder bCryptPasswordEncoder;

    @GetMapping("/")
    public String home(){
        return "HOME";
    }

    @PostMapping("/token") // 토큰 테스트를 위해 임시 컨트롤러 생성
    public String token(){
        return "TOKEN";
    }

    @PostMapping("join")
    public String join(@RequestBody UserEntityJWT userEntityJWT) {
        userEntityJWT.setPassword(bCryptPasswordEncoder.encode(userEntityJWT.getPassword())); // 비밀번호 암호화
        userEntityJWT.setRole("user"); // 회원가입 기본 역할 세팅
        userRepository.save(userEntityJWT);
        return "회원가입이 완료되었습니다.";
    }
}

postman으로 회원가입에 필요한 정보 send해보기

json형식으로 각 값을 보내 컨트롤러가 정상 작동하여 회원가입이 완료되었다는 print문이 출력되었습니다.

DataBase

저장된 값을 확인해 보면 회원정보가 저장되면서 id 값은 자동으로 값이 부여되었고 비밀번호는 입력한 값이 노출되지 않도록 암호화가 잘 되어있습니다 role은 컨트롤러에서 기본적으로 user 로 값을 주었습니다. userName값에도 입력한 값이 정상적으로 저장된 것을 확인할 수 있었습니다.

JWT - 토큰 로그인 시도

Tue, 02 May 2023 09:06:02 GMT

패키지 구조

PrincipalDetails

package com.choigoyo.config.auth;

import com.choigoyo.entity.UserEntityJWT;
import lombok.NoArgsConstructor;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;

import java.util.ArrayList;
import java.util.Collection;

@NoArgsConstructor // 기본 생성자
public class PrincipalDetails implements UserDetails {
    private UserEntityJWT user;

    // 생성자
    public PrincipalDetails (UserEntityJWT user){
        this.user = user;
    }

    @Override
    public Collection getAuthorities() {
        Collection authorities = new ArrayList<>();
        /*
        *  user.getRoleList()를 통해 해당 유저가 가지고 있는 모든 역할(Role)을 가져온 뒤, 각각의 역할에 대한 GrantedAuthority 객체를 생성하여 이를 authorities 리스트에 추가
        *  GrantedAuthority는 권한 정보를 나타내는 인터페이스
        * */
        user.getRoleList().forEach(r ->{
            authorities.add(() -> r);
        });
        return null;
    }

    @Override
    public String getPassword() {
        return user.getPassword();
    }

    @Override
    public String getUsername() {
        return user.getUserName();
    }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return true;
    }
}

getAuthorities() 메소드는 해당 유저 객체가 가지고 있는 권한 정보를 Spring Security가 이해할 수 있는 형태로 반환하는 역할을 합니다.

위 코드에서는 user.getRoleList()를 통해 해당 유저가 가지고 있는 모든 역할(Role)을 가져온 뒤, 각각의 역할에 대한 GrantedAuthority 객체를 생성하여 이를 authorities 리스트에 추가하고 있습니다.

Spring Security에서 GrantedAuthority는 권한 정보를 나타내는 인터페이스이며, 각각의 권한은 문자열 형태로 저장됩니다.

위 코드에서는 람다식을 이용하여 역할(Role) 이름을 GrantedAuthority 객체로 변환하여 authorities 리스트에 추가하고 있습니다.

따라서 getAuthorities() 메소드는 해당 유저 객체가 가지고 있는 모든 역할에 대한 GrantedAuthority 리스트를 반환하는 역할을 합니다.

이외 @Override 메서드는 spring security 시리즈에 정리하였으므로 다음으로 넘어가겠습니다.

PrincipalDetailsService

package com.choigoyo.config.auth;

import com.choigoyo.entity.UserEntityJWT;
import com.choigoyo.repository.UserRepository;
import lombok.RequiredArgsConstructor;
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;

@Service
@RequiredArgsConstructor
public class PrincipalDetailsService implements UserDetailsService {

    private final UserRepository userRepository;

    @Override
    public UserDetails loadUserByUsername(String userName) throws UsernameNotFoundException {
        System.out.println("PrincipalDetails 의 loadUserByUsername()");
        UserEntityJWT userEntity = userRepository.findByUserName(userName);
        return new PrincipalDetails(userEntity);
    }
}

UserRepository

package com.choigoyo.repository;

import com.choigoyo.entity.UserEntityJWT;
import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository {
    UserEntityJWT findByUserName(String userName);
}

postman으로 요청 시도

PrincipalDetailsService 클래스는 http://localhost:8081/login요청이 들어왔을 때 동작을 합니다. 하지만 설정에서 Spring Security 기본 로그인 요청 주소를 SecurityConfig 설정에 form 로그인을 사용하지 않겠다 정했기 때문에 404에러가 발생하게됩니다.

JwtAuthenticationFilter

로그인 시도를 테스트하기위해 필터를 추가해 주었습니다.

package com.choigoyo.config.JWT;

import lombok.RequiredArgsConstructor;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@RequiredArgsConstructor
public class JwtAuthenticationFilter extends UsernamePasswordAuthenticationFilter {

    private final AuthenticationManager authenticationManager;


    // http://localhost:8081/login 요청이 들어오면 authenticationManager 통해서 로그인시도
    @Override
    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {
        System.out.println("JwtAuthenticationFilter : 로그인 시도중...");
        return super.attemptAuthentication(request, response);
    }
}

Spring Security 의 UsernamePasswordAuthenticationFilter 를 확장하여 사용하게되면 사용자가 http://localhost:8081/login 주소로 userName,password 를 post 형식으로 전송하였을 때 UsernamePasswordAuthenticationFilter 가 동작합니다.

SecurityConFig 클래스에 form 로그인을 비활성화 시켜서 동작하지 않는 상태이나, JwtAuthenticationFilter 를 다시 SecurityConFig 클래스에 등록해주면 동작하게됩니다.

SecurityConFig

만들어 둔 필터를 추가해주고 postman으로 로그인 요청을 보내면 필터가 잘 작동하는지 확인해보겠습니다.

postman 으로 post요청 send 해보기

404 에러는 사라졌고, 500에러가 생겼지만 아직 코드를 추가하지 않아서 생긴 오류니 무시하고 intelliJ 콘솔창을 확인해보겠습니다.

메서드가 정상적으로 실행되어 print문이 출력됩니다.

JWT -임시 토큰 만들어서 테스트하기

Sun, 30 Apr 2023 12:41:53 GMT

Filter1

package com.choigoyo.filter;
import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class Filter1 implements javax.servlet.Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {

        HttpServletRequest req = (HttpServletRequest)request;
        HttpServletResponse res = (HttpServletResponse)response;

        String authorization = req.getHeader("Authorization");
        System.out.println(authorization);

        System.out.println("필터1");
        chain.doFilter(req,res);

    }
}

HttpServletRequest의 getHeader() 메소드는 요청에 특정 헤더가 없는 경우 null을 반환합니다. 따라서 Authorization 헤더가 없는 요청에서는 null이 출력될 수 있습니다.

postman 을 사용해서 Authorization 넘겨보기

postman을 검색하면 다운로드 가능합니다. 테스트 하기 header에 Authorization 값이 들어있지 않아서 null이 들어있었는데, postman으로 hello라는 값을 post형식으로 넘겨보겠습니다. 정상적으로 값을 출력하는 것을 확인했습니다. 이제는 어떤 조건을 만들어서 조건을 만족하면 컨트롤러와 매핑되고 조건에 부합하지 않으면 컨트롤러에 접근하지 못하도록 필터 코드를 수정해보겠습니다.

if-else 문을 사용해서 조건을 걸어 choigoyo라는 값이 일치하면 컨트롤러와 매핑되어 뷰페이지를 반환하고 아니면 인증실패를 띄우도록 했습니다.

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

public class Filter1 implements javax.servlet.Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {

        HttpServletRequest req = (HttpServletRequest)request;
        HttpServletResponse res = (HttpServletResponse)response;

        // post 요청일 경우에만
        // 토큰이 넘어오면 인증 시도 넘어오지 않으면 컨트롤러로 접근 불가
        if (req.getMethod().equals("POST")) {
            System.out.println("POST 요청이 확인되었습니다.");
            String authorization = req.getHeader("Authorization");
            System.out.println(authorization);
            System.out.println("필터1");

            // header 의 Authorization 이 choigoyo 일때만 체인필터를 타도록 조건 걸기
            if (authorization.equals("choigoyo")) {
                chain.doFilter(req, res);
            } else {
                PrintWriter out = res.getWriter();
                out.println("인증 실패");
            }
        }
    }
}

토큰을 언제 만들어 줘야할까 ?

사용자의 로그인 정보가 검증되어 사용자를 인증했을 때 토큰을 만들어서 로그인이 완료되면 로그인 완료페이지와 같은 응답과 함게 보내면 됩니다.

토큰을 받은 사용자는 서버에 다른 요청들을 할 때 마다 HTTP 헤더의 Authorization에 value값으로 토큰을 가지고 서버에 요청을 보내게됩니다.

이제 서버는 사용자가 응답과함께 보낸 토큰을 대표적으로 RSA 또는 HS256과 같은 방식으로 검증만 하면 됩니다.

JWT - Filter 등록 테스트

Sat, 29 Apr 2023 18:14:27 GMT

Filter ?

JWT에서 Filter는 인증 및 인가를 처리하는 역할을 합니다. 일반적으로 Spring Security와 연동되어 사용되며, 인증 및 인가를 처리하기 전에 Filter가 요청을 가로채고 필요한 처리를 수행한 후 다음 단계로 요청을 전달합니다.

JWT에서 Filter는 JWT 토큰을 검증하고, 만료 기간을 확인하며, 유저 정보를 검증하고, 권한을 확인하는 등의 작업을 수행합니다. 이를 통해 서버는 보안성을 높이면서도 유연한 인증 및 인가 처리가 가능합니다.

인증과 인가 ?

인증(Authentication)은 사용자가 누구인지 확인하는 과정이며, 인가(Authorization)는 해당 사용자가 어떤 자원에 접근할 수 있는 권한이 있는지 확인하는 과정입니다.

인증은 대표적으로 사용자의 아이디와 패스워드를 입력하여 로그인하는 과정이 있습니다. 이를 통해 사용자가 누구인지 확인하고, 로그인한 사용자에게는 인증토큰(Authentication Token)이 발급됩니다.

인가는 인증된 사용자가 어떤 자원(Resource)에 접근할 수 있는지 여부를 확인하는 과정입니다. 예를 들어, 관리자 권한을 가진 사용자는 관리자 페이지에만 접근할 수 있도록 설정할 수 있습니다. 이를 위해 사용자의 권한 정보가 필요하며, 대표적으로 권한 부여(Authorization)를 통해 권한을 관리합니다.

패키지 구조

Filter1

package com.choigoyo.filter;


import javax.servlet.*;
import java.io.IOException;

public class Filter1 implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        System.out.println("필터1");
        chain.doFilter(request,response);

    }
}

Filter를 관리할 패키지를 생성하고 테스트 할 Filter파일을 작성하여 테스트해보겠습니다.

SecurityConfig

httpSecurity.addFilter(new Filter1());

위 코드를 SecurityConfig 파일에 추가하고 실행을 누르면 아래와 같은 오류가 발생합니다.

Caused by: org.springframework.beans.BeanInstantiationException: 
Failed to instantiate [javax.servlet.Filter]: 
Factory method 'springSecurityFilterChain' threw exception; 
nested exception is java.lang.IllegalArgumentException: 
The Filter class com.choigoyo.filter.Filter1 does not have a registered order and cannot be added without a specified order. 
Consider using addFilterBefore or addFilterAfter instead.

오류 메시지를 확인해보면 filter.Filter1 클래스가 등록된 순서가 없어서 springSecurityFilterChain 에 추가할 수 없다고 나와 있습니다.

이를 해결하는 방법으로는 Filter1 클래스에 @Order 어노테이션을 사용하여 등록 순서를 명시하거나, SecurityConfig.configure 메서드에 addFilterBefore or addFilterAfter 를 사용하여 순서를 필터 순서를 지정해줄 수도 있습니다.

Spring 필터체인 순서

SecurityConfig 필터 순서 지정해주기

@EnableWebSecurity
@Configuration
@RequiredArgsConstructor
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    private final CorsFilter corsFilter;

    @Override
    protected void configure(HttpSecurity httpSecurity) throws Exception {
        // Filter의 순서를 지정해 줌
        httpSecurity.addFilterBefore(new Filter1(),BasicAuthenticationFilter.class); 
        httpSecurity.csrf().disable();
        httpSecurity.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS) // session을 사용하지 않는다
                .and()
                .addFilter(corsFilter)  // @CrossOrigin(인증 없을 때) , 시큐리티 필터에 등록(인증 있을 때)
                .formLogin().disable() // id pw 로그인을 form 로그인을 하지 X
                .httpBasic().disable()
                .authorizeRequests()
                .antMatchers("/api/v1/user/**")
                .access("hasRole('user') or hasRole('manager') or hasRole('admin')")
                .antMatchers("/api/v1/manager/**")
                .access("hasRole('manager') or hasRole('admin')")
                .antMatchers("/api/v1/admin/**")
                .access("hasRole('admin')")
                .anyRequest().permitAll(); // 설정 외 모든 경로는 인증없이 접근가능
    }
}

httpSecurity.addFilterBefore(new Filter1(),BasicAuthenticationFilter.class);

이전 코드와 다르게 Filter1이 BasicAuthenticationFilter 이전에 동작하도록 수정했습니다.

또 다른 방법으로는 config 패키지에 FilterConfig 클래스를 작성하여 설정해주는 방법도 있습니다.

FilterConfig

package com.choigoyo.config;

import com.choigoyo.filter.Filter1;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration // IoC (Inversion of Control) 제어의 역전을 의미
public class FilterConfig {

    @Bean
    public FilterRegistrationBean filter1(){
        FilterRegistrationBean bean = new FilterRegistrationBean<>(new Filter1());
        bean.addUrlPatterns("/*"); // 모든 요청에서 필터를 적용
        bean.setOrder(0); // 필터의 순서 지정 / 우선순위 가장 높음
        return bean;
    }
}

FilterConfig 파일에 필터에 대한 내용을 설정해주고

웹브라우저에 요청을 해서 오류 없이 잘 동작하는 것을 확인했습니다.

같은 방식으로 필요한 필터를 만들어 filterConfig에서 설정하여 실행하면 됩니다.

필터의 우선순위

이제 필터의 우선순위를 테스트해 보겠습니다. 먼저 우선순위 체크를 위해 필터1, 필터2, 필터3을 준비하고, 2개의 필터는 FilterConfig에 우선순위를 정한 뒤, 나머지 1개의 필터는 SecurityConfig에 넣어 실행해 보도록 하겠습니다.

package com.choigoyo.config;

import com.choigoyo.filter.Filter1;
import com.choigoyo.filter.Filter2;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration // IoC (Inversion of Control) 제어의 역전을 의미
public class FilterConfig {

    @Bean
    public FilterRegistrationBean filter1(){
        FilterRegistrationBean bean = new FilterRegistrationBean<>(new Filter1());
        bean.addUrlPatterns("/*"); // 모든 요청에서 필터를 적용
        bean.setOrder(0); // 필터의 순서 지정 / 우선순위 가장 높음
        return bean;
    }
    @Bean
    public FilterRegistrationBean filter2(){
        FilterRegistrationBean bean = new FilterRegistrationBean<>(new Filter2());
        bean.addUrlPatterns("/*"); // 모든 요청에서 필터를 적용
        bean.setOrder(1); // 필터의 순서 지정
        return bean;
    }
}

SecurityConfig에 등록한 Filter3이 가장먼저 실행되고 이후 나머지 Filter1,Filter2 는 우선순위 지정에 따라 실행되었습니다.

SecurityConfig에 등록한 Filter3은 addFilterBefore 이나 addFilterAfter 모두 같은 결과가 나옵니다.

즉, Security 필터체인이 만들어낸 필터체인보다 먼저 실행이 된다는 것 입니다.

필터가 적용되는 시점을 Spring 필터체인 순서를 참고하여 SecurityConfig에 등록하여 사용할 수 있습니다.

JWT - Bearer 인증 방식

Sat, 29 Apr 2023 16:41:44 GMT

위 그림은 session에 요청하고 응답하는 과정을 간단히 표현한 그림입니다.

여러 개의 서버를 사용하는 경우, 서버들이 세션을 공유할 수 없습니다. 즉, 사용자의 요청이 다른 서버로 전달되면 해당 서버는 그 전 서버와 공유하지 않는 별도의 세션을 생성하게 됩니다.

따라서, 사용자의 모든 요청에 대해 같은 세션을 유지하기 위해서는 어떤 서버에서 처리하느냐에 따라 세션이 다르게 유지되는 문제가 발생할 수 있습니다.

이러한 문제를 해결하기 위해서는, 서버들 간에 세션 정보를 공유하는 방법이 필요합니다.

대표적인 방법으로는 로드밸런싱 기능을 가진 로드밸런서를 사용하여 세션을 공유하거나, 세션을 서버 외부에 저장하는 세션 클러스터링 등이 있습니다.

하지만 이러한 방법들은 구현하기 어렵고, 관리하기도 복잡하기 때문에 서버를 추가할 때마다 그만큼 비용이 증가하게 됩니다.

따라서 최근에는 이러한 문제를 해결하기 위해 세션 대신 JWT(JSON Web Token)을 사용하는 경우가 많아졌습니다.

JWT는 서버에서 세션을 관리하는 것이 아니라 클라이언트에게 발급된 토큰을 통해 인증을 수행하므로, 서버 간의 세션 공유 문제를 해결할 수 있습니다.

JWT - Bearer 인증

Fri, 28 Apr 2023 15:49:21 GMT

클라이언트가 서버측에 JavaScript로 Ajax 요청을 보내면, 보통 브라우저에서는 서버로부터 받은 쿠키를 사용하여 세션 ID를 저장합니다.

그리고 브라우저는 이 세션 ID를 다음 요청에서 서버로 전달합니다. 하지만 이 방식은 다음과 같은 단점이 있습니다.

쿠키 사용 여부: 다른 도메인 간 요청이나 HTTP API 호출 같은 일부 상황에서는 쿠키를 사용할 수 없기 때문에 이 방식을 사용할 수 없습니다.

Scale-out을 위한 분산 환경에서 문제가 발생: 세션을 저장하는 기본적인 방법인 메모리에 저장된 세션을 사용하는 경우, 서버의 스케일 아웃이나 로드 밸런싱을 수행하는 경우 세션이 분산되어 문제가 발생할 수 있습니다.

메모리 부족: 서버 메모리에 저장된 세션 데이터가 너무 많으면 서버 성능에 영향을 미치거나 서버 자체가 다운될 수 있습니다.

JWT를 사용하면, 서버 측에서 세션을 유지하지 않아도 되므로 서버의 확장성이 높아지며, stateless 방식으로 인증이 가능합니다.

따라서, 클라이언트 측에서 서버에 대한 요청을 할 때 매번 JWT를 포함시켜 보내고, 서버에서는 JWT를 이용하여 인증을 처리하면 됩니다.

이를 통해, 서버 측에서 세션 관리와 같은 부담을 줄일 수 있습니다.

또한, JWT의 bearer 인증 방식을 이용하면, 클라이언트에서 JWT를 포함시켜 요청을 보내면 서버에서는 JWT의 유효성만 검사하고, 별도의 인증 정보를 확인하지 않아도 됩니다.

이러한 이유로, JWT를 사용하면 세션 관리의 단점을 해결하고, 확장성과 보안성을 높일 수 있습니다.

JWT의 Bearer 인증 방식은 HTTP 헤더의 Authorization 필드를 이용하여 인증을 수행하는 방식입니다.

Bearer 인증 방식에서는 클라이언트가 인증 요청을 보낼 때, JWT 토큰을 HTTP 헤더의 Authorization 필드에 담아서 보내게 됩니다.

이때, JWT 토큰은 "Bearer " 문자열과 함께 Authorization 필드에 담겨서 전송됩니다. 서버는 이 JWT 토큰을 수신해서 유효성 검증을 수행하고, 인증이 성공하면 요청에 대한 응답을 반환합니다.

Bearer 인증 방식은 간단하면서도 확장성이 높아서, 대부분의 웹 애플리케이션에서 사용됩니다. 또한, JWT 토큰을 이용하기 때문에 세션 관리를 하지 않아도 되고, 로그인 상태 유지 문제를 해결할 수 있습니다.

JWT 학습을 위한 Security 설정

Fri, 28 Apr 2023 09:02:11 GMT

README.md

JSON Web Token 학습

개발 환경

Project - Gradle - Groovy
Language - Java 11
Spring Boot Ver - 2.7.11
Dependencies
1. DEVELOPER TOOLS - Spring Boot DevTools
2. DEVELOPER TOOLS - Lombok
3. java-jwt', version: '4.2.1'
4. WEB - Spring Web
5. SECURITY - Spring Security
6. SQL - MySQL Driver
7. JPA

build.gradle

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    implementation 'org.springframework.boot:spring-boot-starter-security'
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation group: 'com.auth0', name: 'java-jwt', version: '4.2.1'
    compileOnly 'org.projectlombok:lombok'
    developmentOnly 'org.springframework.boot:spring-boot-devtools'
    runtimeOnly 'com.mysql:mysql-connector-j'
    annotationProcessor 'org.projectlombok:lombok'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
    testImplementation 'org.springframework.security:spring-security-test'
}

패키지 구조

UserEntityJWT

package com.choigoyo.entity;

import lombok.Data;
import lombok.NoArgsConstructor;

import javax.persistence.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

@NoArgsConstructor // 기본 생성자
@Data
@Entity
@Table(name ="UserEntityJWT")// db에 생성될 테이블 이름
public class UserEntityJWT {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY) // id값 자동 증감
    private Long id; // 회원번호
    private String userName; // 회원 이름
    private String password; // 회원 비밀번호
    private String role; // 회원 역할 User, Manager ,Admin

    public List getRoleList(){
        if (this.role.length() > 0) {
            return Arrays.asList(this.role.split(",")); // 콤마 기준으로 잘라서 반환
        }
        return new ArrayList<>(); // null이 뜨는 것을 방지하기 위해 임시로 리스트 반환
    }

}

RestApiController

package com.choigoyo.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class RestApiController {


    @GetMapping("/")
    public String home(){
        return "HOME";
    }
}

SecurityConfig

package com.choigoyo.config;

import lombok.RequiredArgsConstructor;
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.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.web.filter.CorsFilter;


@EnableWebSecurity
@Configuration
@RequiredArgsConstructor
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    private final CorsFilter corsFilter;

    @Override
    protected void configure(HttpSecurity httpSecurity) throws Exception {
        httpSecurity.csrf().disable();
        httpSecurity.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS) // session을 사용하지 않는다.
        .and()
                .addFilter(corsFilter)  // @CrossOrigin(인증 없을 때) , 시큐리티 필터에 등록(인증 있을 때)
                .formLogin().disable() // id pw 로그인을 form 로그인을 하지 X
                .httpBasic().disable()
                .authorizeRequests()
                .antMatchers("/api/v1/user/**")
                .access("hasRole('user') or hasRole('manager') or hasRole('admin')")
                .antMatchers("/api/v1/manager/**")
                .access("hasRole('manager') or hasRole('admin')")
                .antMatchers("/api/v1/admin/**")
                .access("hasRole('admin')")
                .anyRequest().permitAll(); // 설정 외 모든 경로는 인증없이 접근가능
    }
}

이전 Spring Security와 다른점은 STATELESS로 세션을 사용하지 않고, CrossOrigin 정책을 사용하지 않는다는 설정을하였고 Formlogin을 사용하지 않았습니다.

참고

httpSecurity.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS) // session을 사용하지 않는다.

JWT를 사용하는 경우, 토큰 자체가 인증에 필요한 모든 정보를 가지고 있기 때문에 서버 측에서는 세션을 유지할 필요가 없습니다. 따라서 Spring Security 설정에서 STATELESS를 사용하여 서버가 상태를 유지하지 않도록 구성합니다.

.addFilter(corsFilter)

CrossOrigin 정책은 브라우저의 보안상의 이유로 동일한 출처에서 오는 리소스에 대한 제한을 두는 것입니다. 즉, 서로 다른 출처에서 오는 리소스 간에 접근을 제어합니다. JWT를 사용하는 경우, 인증 정보를 포함하는 토큰이 서버에 의해 생성되어 다른 도메인의 클라이언트에서도 인증이 가능해야 합니다. 따라서 CrossOrigin 정책을 따르지 않는 것입니다.

.formLogin().disable()

Form login은 Spring Security에서 기본적으로 제공하는 로그인 방식 중 하나입니다. 그러나 JWT를 사용하는 경우, 로그인 페이지를 통해 인증하는 방식이 아닌, 클라이언트에서 JWT를 생성하여 서버에 전달하고, 서버에서는 JWT의 유효성을 검증하여 인증하는 방식을 사용합니다. 따라서 Form login 설정은 필요하지 않습니다.

.httpBasic().disable()

.httpBasic().disable()는 Spring Security의 기본 인증 방식 중 하나인 HTTP Basic Authentication을 비활성화하는 설정입니다. 이 설정을 통해 HTTP Basic 인증을 사용하지 않고 JWT 토큰을 사용한 인증을 적용할 수 있습니다.

HTTP Basic Authentication은 클라이언트에서 사용자 이름과 비밀번호를 직접 전송하는 방식으로, 인증 정보가 암호화되지 않고 평문으로 전송되므로 보안에 취약합니다. 따라서 JWT 토큰과 같이 보안 수준이 높은 인증 방식을 사용하기 위해 HTTP Basic Authentication을 비활성화하고 다른 방식의 인증을 적용하는 것이 좋습니다.

CorsConfig

package com.choigoyo.config;


import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;

@Configuration
public class CorsConfig {

    @Bean
    public CorsFilter corsFilter(){
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        CorsConfiguration config = new CorsConfiguration();
        config.setAllowCredentials(true); // 서버가 응답할 때 json 을 js 에서 처리할 수 있게 할지 설정
        config.addAllowedOrigin("*"); // 모든 ip에 응답 허용
        config.addExposedHeader("*"); //  모든 header 에 응답 허용
        config.addAllowedMethod("*"); // 모든 post ,get, delete , patch 요청을 허용
        source.registerCorsConfiguration("/api/**",config);
        return new CorsFilter(source);
    }

}

인증없이 index 페이지를 반환하는 것을 확인하기

choigoyo_o.log

[flutter] MacOs Sequioa 15.0 업데이트 후 Xcode error

evaluateJavaScript(_:completionHandler:)

include of non-modular error

Command PhaseScriptExecution failed with a nonzero exit code

Flutter SingleChildScrollView 내부에 Expanded 위젯 사용시 에러 해결방법

Xcode 에서 B/BL out of range 135384124 (max +/-128MB) to '' 를 해결한 방법

문자, 문자열 리터럴 그리고 문자열 결합 개념정리

문자, 문자열 리터럴 그리고 문자열 결합

문자

문자열

문자열 결합

Java와 spring boot 게시판 프로젝트 - 회원 가입 이메일 인증

회원가입 폼 만들기

회원가입

이메일인증 코드 전송

Javascript

Controller

Service

member컨트롤러 회원정보 save하기

MemberService에서 회원정보 저장

MemberRepository 인터페이스

Java와 spring boot 게시판 프로젝트 - 테이블 설계

테이블 설계

Java - literal의 타입, 접두사와 접미사 내용 정리

literal의 타입, 접두사와 접미사

정수 리터럴

부동소수점 리터럴

문자 리터럴

문자열 리터럴

불리언 리터럴

Java - 변수와 상수 리터럴 개념 정리

변수와 상수, 그리고 리터럴

변수(variable)

상수(constant)

리터럴(literal)

Java - 변수 타입

변수의 타입

Java - 변수 variable

변수(variable) 란 ?

변수에 값을 할당하려면 다음과 같이 작성합니다.

변수의 초기화

변수의 세가지 유형

JWT - 인증이 필요한 페이지 요청시 토큰으로 권한 인증

인증된 사용자에게 토큰을 담은 응답하기

권한이 필요한 페이지를 요청했을 때

JWT - 사용자 로그인 요청시 토큰을 생성하여 응답하기

JwtAuthenticationFilter 의 successfulAuthentication 메서드

postman으로 로그인 완료시 클라이언트에게 토큰과함께 응답하는지 확인하기

JWT - json 로그인 요청에 대한 파싱과 사용자 인증 테스트

postman 로그인 테스트 - x-www-form-urlencoded 회원정보 send

postman 로그인 테스트 - json 회원정보 send

json 으로 넘어온 값을 파싱하기

JWT - 회원가입 로직 작성하기

JwtApplication

RestApiController

HOME

TOKEN

postman으로 회원가입에 필요한 정보 send해보기

DataBase

JWT - 토큰 로그인 시도

패키지 구조

PrincipalDetails

PrincipalDetailsService

UserRepository

JwtAuthenticationFilter

SecurityConFig

postman 으로 post요청 send 해보기

JWT -임시 토큰 만들어서 테스트하기

Filter1

postman 을 사용해서 Authorization 넘겨보기

토큰을 언제 만들어 줘야할까 ?

JWT - Filter 등록 테스트

Filter ?

인증과 인가 ?

패키지 구조

Filter1

SecurityConfig

Spring 필터체인 순서

SecurityConfig 필터 순서 지정해주기