상속+

super

super : 내가 상속받은 부모 class를 가르키는 키워드

• super.함수() : 상속받은 부모 class의 모든 함수를 호출 할 수 있다.

오버로딩 (overloading)

한 class 내에 동일한 이름의 메소드를 여러개 정의 하는 것

<조건>

• 메소드 이름이 동일해야 한다.
• 매개변수의 개수 혹은 타입이 달라야한다.

[부적합 코드]

[정상 코드]

오버라이딩 (overriding)

부모 class로부터 상속받은 메소드의 내용을 변경 하는 것 상속받은 메소드를 그대로 사용하기도 하지만, 필요에 의해 변경해야 할 경우

<조건>

• 부모 class의 메소드와 이름이 같아야 한다.
• 부모 class의 메소드와 매개변수가 같아야 한다.
• 부모 class의 메소드와 반환타입이 같아야 한다.

[정상 코드]

예외,에러처리

[자바에 미리 정의 되어있는 예외 클래스]

[입력 방법]

try {
    // 예외가 발생할 가능성이 있는 코드를 구현한다.
} catch (FileNotFoundException e) {
    // FileNotFoundException이 발생했을 경우,이를 처리하기 위한 코드를 구현한다.
} catch (IOException e) {
    // FileNotFoundException이 아닌 IOException이 발생했을 경우,이를 처리하기 위한 코드를 구현한다.
} finally {
    // 예외의 발생여부에 관계없이 항상 수행되어야하는 코드를 구현한다.
}

하위 에러처리를 더 위의 catch문에 적어준다.

생성자란?

• 인스턴스가 생성될 때 사용되는 '인스턴스 초기화 메소드' 입니다.
• 즉, new 와 같은 키워드로 해당 클래스의 인스턴스가 새로 생성될 때, 자동으로 호출되는 메소드입니다.
• 인스턴스 변수를 초기화 하는 용도로 사용합니다.

[ 작성 예시 ]

class Phone {
    String model;
    String color;
    int price;

    // 생성자
    Phone(String model, String color, int price) {
        this.model = model;
        this.color = color;
        this.price = price;
    }
}

public class Main {
    public static void main(String[] args) {
        Phone galaxy = new Phone("Galaxy10", "Black", 100);

        Phone iphone =new Phone("iPhoneX", "Black", 200);

        System.out.println("철수는 이번에 " + galaxy.model + galaxy.color + " + 색상을 " + galaxy.price + "만원에 샀다.");
        System.out.println("영희는 이번에 " + iphone.model + iphone.color + " + 색상을 " + iphone.price + "만원에 샀다.");
    }
}

[ 동작 설명 ]

• 위 그림과 같이 new Phone("Galaxy10", "Black", 100); 에서 새로운 인스턴스가 생성되면 Phoe class에서 새로운 생성자Phone(~, ~, ~) 를 만들어서 다시 정의해 주고 이 class를 활용에 사용한다.

만약! 생성자를 만들어주지 않는다면?

• class 에 선언된 변수는 instance 가 생성될 때 값이 초기화(initialize)된다. 이 때, 변수의 선언부나 생성자를 통해서 초기화를 해주지 않는다면, 기본값(default value)를 가지게 된다. -> 기본값 ex) 0, 0.0, null

상속이란?

• 상속이란 기존의 클래스를 재사용하는 방식 중의 하나입니다.
• 한 번 작성한 코드가 재사용이 필요하다면, 변경사항만 코드로 작성하므로 상대적으로 적은 양의 코드를 작성할 수 있게 됩니다.
• 이렇게 코드를 재사용하면, 코드와 클래스가 많아질수록 관리가 용이하다는 장점이 있습니다.

[ 작성 예시 ]

class Animal {
    String name;

    public void cry() {
        System.out.println(name + " is crying.");
    }
}

class Dog extends Animal {

    Dog(String name) {
        this.name = name;
    }

    public void swim() {
        System.out.println(name + " is swimming!");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("코코");
        dog.cry();
        dog.swim();

        Animal dog2 = dog;
        dog2.cry();
//        dog2.swim(); // compile error
    }
}

[ 동작 설명 ]

• Dog class가 Animal class를 상속받아 Dog class에서는 Animal의 cry()함수랑 Dog의 swim()함수를 다 사용 가능하나 Animal에서는 본인의 함수 cry() 만 사용 가능하다.

1. 연산자

int num1 = 10;
int num2 = 5; 

// 산술연산
System.out.println(num1 + num2); // 더하기 연산
System.out.println(num1 - num2); // 빼기 연산
System.out.println(num1 * num2); // 곱하기 연산
System.out.println(num1 / num2); // 나누기 연산
System.out.println(num1 % num2); // 나머지 연산

// 대입 연산자
num1 += num2; // num1 = num1 + num2
num1 -= num2; // num1 = num1 - num2
num1 *= num2; // num1 = num1 * num2
num1 /= num2; // num1 = num1 / num2
num1 %= num2; // num1 = num1 % num2 

// 관계 연산자
int num1 = 10;
int num2 = 20;
int num3 = 10;

System.out.println(num1 > num2); // 10 > 20
System.out.println(num1 >= num3); // 10 >= 10
System.out.println(num1 < num2); // 10 < 20
System.out.println(num1 <= num2); // 10 <= 20
System.out.println(num1 == num3); // 10 == 10
System.out.println(num1 != num2); // 10 != 20

// 논리 연산자
boolean a = true;
boolean b = false;

System.out.println(a && b);
// &&는 두가지 모두 참일 경우에는 true를, 그렇지 않을 경우에는 false를 반환합니다.
System.out.println(a || b);
// ||는 두가지 모두 거짓일 경우에는 false를, 그렇지 않을 경우에는 true를 반환합니다.
System.out.println(!b);
// !는 피연산자의 논리값을 바꿉니다. true는 false로 , false는 true로 반환합니다.

// 비트 연산자 (URL 참고) 
// http://www.tcpschool.com/c/c_operator_bitwise

2. 조건문

// if문
if (조건식){
    실행 코드
}

// 예시
int check = 100;
int num1 = 150;
if (num1 > check) {
    System.out.println("100보다 큰 수입니다");
}

// if ~ else if
int num2 = 50;
if (num1 > check) {
    System.out.println("100보다 큰 수입니다");
} else {
    System.out.println("100보다 작은 수입니다.");
}


// switch문
switch (입력 변수){
    case 입력값1 : 실행 구문
        break;
    case 입력값2 : 실행 구문
        break;
    case 입력값3 : 실행 구문
        break;
    default: 기본 실행 구문
        break;
}

// 예시 
char score = 'A';
switch (score) {
    case 'A':
        System.out.println("A등급입니다.");
        break;
    case 'B':
        System.out.println("B등급입니다.");
        break;
    case 'C':
        System.out.println("C등급입니다.");
        break;
    default:
        System.out.println("C등급보다 낮은 등급입니다.");
        break;
}


// 삼항연산자 
// '?'를 기준으로 조건식이 true일 경우에는 A 코드를, false일 경우에는 B 코드를 수행합니다.
(조건식) ? A : B

// 예시
int a = 5;

String reuslt = (a < 10) ? "10보다 작습니다." : "10보다 큽니다.";
System.out.println(reuslt);

2. 반복문

// for문
for(초기값 ; 조건식 ; 증감식){
    실행 코드 블럭
}

// 예시
int sum = 0;

for (int i = 0; i < 10; i++) {
    sum += (i + 1);
}
System.out.println(sum);


// for - each문
for (String day : days) {
    System.out.println(day);
}


// while문
while(조건식){
    실행 코드 블럭
}

// 예시
int i = 0;
int sum = 0;
while (i < 10) {
    sum += i + 1;
    i += 1;
}
System.out.println(sum);

// break
int i = 0;
while (i < 10){
    if (i==5){
        break;
    }
    i += 1;
}
System.out.println(i);

// continue
for(int i=0;i<10;i++){
  if (i==5){
      continue;
  }
  System.out.println(i);
}

class Phone {
    String model;
    String color;
    int price;

    Phone(String model, String color, int price) {
        this.model = model;
        this.color = color;
        this.price = price;
    }
}

public class Main {
    public static void main(String[] args) {
        Phone galaxy = new Phone("Galaxy10", "Black", 100);

        Phone iphone =new Phone("iPhoneX", "Black", 200);

        System.out.println("철수는 이번에 " + galaxy.model + galaxy.color + " + 색상을 " + galaxy.price + "만원에 샀다.");
        System.out.println("영희는 이번에 " + iphone.model + iphone.color + " + 색상을 " + iphone.price + "만원에 샀다.");
    }
}

GET코드를 다 작성하고 동작을 시켜 보았는데 아래와 같은 오류가 나왔다.

오류 내용의 마지막 부분을 읽어보니 해결 가능할 거 같아 보인다.

오류 마지막 부분 내용

"No property nickName1 found for type User! Did you mean 'NickName'?" 의역 : "사용자 유형에 대해 nickName1 속성을 찾을 수 없습니다! 'NickName'을(를) 의미하셨습니까?"

오류 해결

NickName이라는 변수를 두 Repository에서 같이 사용해서 그런거 같아 한쪽을 지워줬다.

✍🏻 메인페이지 / 사진페이지

기능 | Method | URL | Return |:---:|:---:|:---:|:---: 게시글 가져오기 | GET | /api/upload | Upload 강아지 선택 값 가져오기 | GET | /api/upload | Upload 강아지 사진 가져오기 | GET | /api/upload | Upload 프로필 정보 가져오기 | GET | /api/User{userId} | User 프로필 사진 가져오기 | GET | /api/User{userId} | User

• 내가 구현하는 부분은 다 GET으로 팀원 분들의 URL과 Repository를 설계 해야 돼서 오늘 꽤 많은 난관이 있었다.

문제 POST부분이 아직 구현이 안돼 직접 작성하였다.(이 부분은 팀원분이 작성하신 부분이 있었지만 내 설계랑 맞지않아 조금 수정하였고 내일 회의 해봐야겠다.)

Feed.java (올리는 파일 정보)

@Entity
@Getter
@NoArgsConstructor
@AllArgsConstructor
public class Feed extends Timestamped {
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Id
    private Long idx;                   // ID
                                        //
    @Column(name = "writerIdx")
    private String userId;              // 사용자 아이디
    @Column(nullable = true)
    private String updateDate;          // 글 생성일자 또는 변경일자
    @Column(nullable = true)
    private String mainImagePath;       // 글 메인 이미지 파일명(ex-filename.png)
    @Column(nullable = false)
    private String content;             // 글 내용
    @Column(nullable = false)
    private String address;             // 글 or 사진을 올린 장소
    @Column(nullable = false)
    private String size;                // 강아지 크기
    @Column(nullable = false)
    private Long likeCount;             // 글 좋아요 개수
                                        //
    public Feed(FeedDto feedDto){
        this.idx = feedDto.getIdx();
        this.userId = feedDto.getUserId();
        this.updateDate = feedDto.getUpdateDate();
        this.mainImagePath = feedDto.getMainImagePath();
        this.content = feedDto.getContent();
        this.address = feedDto.getAddress();
        this.size = feedDto.getSize();
        this.likeCount = feedDto.getLikeCount();
    }
}

User.java (사용자 정보)

@Getter
@Entity
@NoArgsConstructor
@AllArgsConstructor
public class User {
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Id
    private Long idx;
                                    //
    @Column(name = "writerIdx")
    private String userId;          // 사용자 아이디
                                    //
    @Column(nullable = false)
    private String ProfileImg;      // 프로필 사진
}

FeedDto

@Getter
@NoArgsConstructor
@AllArgsConstructor
public class FeedDto {
    private Long idx;              // ID
    private String userId;         // 사용자 아이디
    private String updateDate;     // 글 생성일자 또는 변경일자
    private String mainImagePath;  // 글 메인 이미지 파일명(ex-filename.png)
    private String content;        // 글 내용
    private String address;        // 글 or 사진을 올린 장소
    private String size;           // 강아지 크기
    private Long likeCount;        // 글 좋아요 개수
}

UserDto

@Getter
@NoArgsConstructor
@AllArgsConstructor
public class UserDto {
    private Long idx;
    private String userId;          // 사용자 아이디
    private String ProfileImg;      // 프로필 사진
}

내일 내 구현 부분인 MainPage 와 PhotoPage에 해당한 Spring 부분을 구현 할 예정이다.

• API 멤버관리 (id, 이름, 나이)

PUT 오류(404 에러)

코드확인 (Controller - URL 확인)

• put,delete url 오타

  

코드확인 (Controller - URL 확인)

• put,delete url 오타 수정

  

1-2. '==' 과 '===' 차이

• '==' - Equal Operator

  ex) console.log(0 == "0"); // true console.log(0 == ""); // true

• '===' - Strict Equal Operator 문자형식까지 체크해서 비교해 준다.

  ex) console.log(0 === "0"); // false console.log(0 === ""); // false

2. Spring 데이터 저장에 대한 궁금증

Memo(requestDto)를 memoRepository에 저장 Memo 테이블 Repository에서 JpaRepository를 상속 받고있다. 데이터 베이스를 육안으로 확인 할 수 없어 데이터를 어디에 저장하는지 의문 이었는데 곽영호 튜터님께서 JpaRepository를 상속 받으면 자동으로알아서 데이터 베이스에 저장해 둔다고 하셨다. 그리고 위 index파일에서 response값을 어떻게 저장하는지 궁금했는데 해결이 되었다.

3. 네이버 API - GET

• URL : https://openapi.naver.com/v1/search/shop.json?query=hat query=(조회할 상품)
  

• URL : https://openapi.naver.com/v1/search/shop.json?query=hat&display=3 (&&이렇게 이어서 적을 수도있다.) &display=3(상품갯수) &start=2(시작 상품의 index) &sort= sim (유사도순), date (날짜순), asc(가격오름차순) ,dsc(가격내림차순)

출처

https://steemit.com/kr-dev/@cheonmr/js-operator [네이버] https://developers.naver.com/docs/search/shopping/

• findAllByOrderByModifiedAtDesc() : findAll해온 값을 내림차순으로 정리
• index.html에서 POST랑 PUT에서 contentType: "application/json"을 설정 해 주었는데 POSTMAN에서도 설정을 해주는게 JSON형식으로 동작하는 거 같다.

-Spring 학습이 조금 늦었지만 확실히 잡고 프로젝트를 진행하는게 맞다 판단해서 일정의 앞부분에 넣었지만 그래도 최대한 빨리 학습을 끝내야겠다 생각한다.

이전 기능에 새로운 기능들을 더해 팀원분들과 함께 layerd 계획 단계까지 진행했다.

1. 회원가입 & 로그인페이지

2-1. 메인페이지

2-2. 원하는 강아지 피드만 보기 2-3. 게시물 선택시 2-4. 닉네임 선택시 2-5. 해당 위치 클릭시 (그 장소에 올린 사진 모아보기)

3. 사진업로드

내일배움캠프 D+63

(화요일 ~ 금요일)

실시간 강의를 듣는데 진도가 많이 늦어 TIL을 작성하지 않고 편하게 Spring 기능 작성에 모든 시간을 쏟았다. TIl을 간단하게 작성 할 수도 있다 생각했지만 성격상 대충 적는 거에도 뭔가 정리를 해야하는 게 있어 시간을 많이 투자해 일단 잠시 내려두고 다음주 월요일 부터 어느정도 안정화 되면 시작 하려 한다.

(토요일)

휴식

(일요일)

[🎉내배캠 팀원분의 Github 1주년🎉]

같이 수업을 듣는 팀원 분의 Gighub 업로드가 1년을 맞이했다는 소식을 들었다. 잔디를 보니 그동안 많은 시간의 노력이 보이는 거 같다. 같은 팀으로 지내며 수업을 따라가면서 Github 업로드까지 한다는건 쉽지 않은데 그것을 다 하시는 건 정말 대단한것 같다 나도 앞으로 매일 업로드를 하는 정도까지는 아니어도 꾸준히 한주에 5번 정도는 업로드하는 습관을 들여야 겠다. Github 업로드에 있어 많은 귀감이 되었다! 이렇게 해야 전공자라는 소리를 듣는건가... 노력 많이 해야겠다. (-전공자 소리 듣고싶은 비전공자-)

[나의 Github] https://github.com/YuJehyeop [팀원 분의 Github] https://github.com/Lluora

정의

Docker는 애플리케이션을 개발, 배송 및 실행을 해주는 개방형 플랫폼이다.

특징

애플리케이션을 인프라에서 분리할 수 있으므로 소프트웨어를 빠르게 제공할 수 있다.

애플리케이션을 관리하는 것과 동일한 방식으로 인프라를 관리할 수 있다.

Container 라는 격리된 환경에서 애플리케이션을 패키징하고 실행할 수 있는 기능을 제공한다.

Container?

정의

컨테이너는 이미지의 실행 가능한 인스턴스

특징

Docker API 또는 CLI를 사용하여 컨테이너를 생성, 시작, 중지, 이동 또는 삭제할 수 있다.

Container를 하나 이상의 네트워크에 연결하거나, 스토리지를 연결하거나, 현재 상태를 기반으로 새 이미지를 생성할 수도 있다.

기본적으로 Container는 다른 Container 및 해당 HOST System과 비교적 잘 격리되어 있다.

Container의 네트워크, 저장소 또는 기타 기본 하위 시스템이 다른 Container나 HOST System과 얼마나 격리되었는지 제어할 수 있다.

Container는 Image와 Container를 만들거나 시작할 때 제공하는 구성 옵션으로 정의된다.

Container가 제거되면 영구 저장소에 저장되지 않은 상태 변경 사항은 사라진다.

이전 방식과 비교

전통적인 배포시대 (Traditional Deployment)

물리서버에서 실행 : 하나의 물리서버에 여러개의 애플리케이션을 실행하여 리소스를 많이 차지하는 인스턴스가 존재 할 경우 그 외의 애플리케이션들의 성능이 저하될 우려가 있다.

- 해결책으로는 여러 물리 서버를 사용하면 되지만 비용이 많이 든다는 단점이 있다.

가상화된 배포 시대 (Virtualized Deployment)

단일 물리 서버의 CPU에서 여러 가상 시스템(VM)을 실행할 수 있게 한다.

가상화를 사용하면 VM간에 애플리케이션을 격리하고 애플리케이션의 정보를 다른 애플리케이션에서 자유롭게 액세스 할 수 없으므로, 일정 수준의 보안성을 제공할 수 있다.

컨테이너 개발 시대 (Container Deployment)

컨테이너는 VM과 유사하지만 격리 속성을 완화하여 애플리케이션 간에 운영체제(OS)를 공유한다. 그러므로 컨테이너는 가볍다고 여겨진다.

VM과 마찬가지로 컨테이너에는 자체 파일 시스템, CPU 점유율, 메모리, 프로세스 공간 등이 있다. 기본 인프라와의 종속성을 끊었기 때문에, 클라우드나 OS 배포본에 모두 이식할 수 있다

[출처] Docker, Container https://docs.docker.com/get-started/overview/ 이전 방식과 비교 https://kubernetes.io/ko/docs/concepts/overview/what-is-kubernetes/#%EC%97%AC%EC%A0%95-%EB%8F%8C%EC%95%84%EB%B3%B4%EA%B8%B0

내일배움캠프 D+56

( 화요일 )

내일배움캠프 D+57

( 수요일 )

내일배움캠프 D+58

( 목요일 )

스프링 실습 과정에서 코드가 제대로 읽히지 않고 흐름도 파악이 안돼 이래저래 계속 코드를 읽어보았다.

( 금요일 )

내일배움캠프 D+60

( 토요일 )

현재 진행으로는 휴식을 취하면 안되지만 하루라도 쉬지 않으면 다음주를 맞이할 자신이 없어 하루종일 잠자면서 휴식을 취했다.

( 일요일 )

스프링 실습에서 코드를 넣는 과정이 이해가 안가 계속 반복 작업으로 만들어 보다가 시큐리티 부분에서 오류가 자꾸 나와서 일단 급한데로 튜터님 코드를 빌어 작성을 하고 내일 강의에 필요한 부분을 읽어 뒀다.

이대로 가다간 이도저도 안 될거같아 더 열심히 해야하는데 정확한 방법을 잘 모르겠다. 이번주 내로 얼른 나의 방법을 찾아 뒤쳐지는 부분을 조금씩 쫒아와야겠다.

[Acitectuer 설명]

Client -> DB

1. Client에서 요청을 보낸다.
2. Web Interface(MVC)에서 DTO를 생성해준다.
3. DTO를 통해 Service Layer로 보내준다.
4. CRUD를 통해 Repository에 요청한다.
5. Repository의 DAO객체에 Enetity로 RDBMS에 접근한다.

DB -> Client

1. Repository의 DAO객체에서 Enetity로 RDBMS에 접근한다.
2. Repository에서 DTO로 Service Layer와 Presentation Layer에 접근한다.
3. Web Interface(MVC)에서 JSP로 Client에 응답해 준다.

*DTO는 단방향으로 방향 갯수에 맞춰 나누어 그려주었다.

MVC.

MVC 패턴은 어플리케이션을 개발할 때 그 구성 요소를 Model과 View 및 Controller 등 세 가지 역할로 구분하는 디자인 패턴입니다. 비즈니스 처리 로직(Model)과 UI 영역(View)은 서로의 존재를 인지하지 못하고, Controller가 중간에서 Model과 View의 연결을 담당한다.

DTO.

Data Transfer Object의 약자로, 계층 간 데이터 교환 역할을 한다. DB에서 꺼낸 데이터를 저장하는 Entity를 가지고 만드는 일종의 Wrapper라고 볼 수 있는데, Entity를 Controller 같은 클라이언트단과 직접 마주하는 계층에 직접 전달하는 대신 DTO를 사용해 데이터를 교환한다.

DAO.

Data Access Object의 약자로, 실제로 DB에 접근하는 객체다. DAO는 프로젝트의 서비스 모델과 실제 데이터베이스를 연결하는 역할을 하며, JPA에서는 DB에 데이터를 CRUD 하는 Repository 객체들이 DAO라고 볼 수 있다.

Entity.

관계형 데이터베이스 : entity는 저장될 수 있는 어떤 데이터에 관한 사람, 장소, 또는 사물이다. 데이터 모델링 : entity는 분류될 수 있고, 다른 entity들에 대해 정해진 관계를 가지는 데이터 단위이다.

출처: https://linuxism.ustd.ip.or.kr/45 [linuxism]

JSP (JavaServerPages)

Java 언어를 기반으로 하는 Server Side 스크립트 언어

[출처] Layered Acitectuer : https://velog.io/@yu_jep/%EB%82%B4%EC%9D%BC%EB%B0%B0%EC%9B%80%EC%BA%A0%ED%94%84-D60 MVC : https://tecoble.techcourse.co.kr/post/2021-04-25-dto-layer-scope/ DTO, DAO : https://velog.io/@ohzzi/Entity-DAO-DTO%EA%B0%80-%EB%AC%B4%EC%97%87%EC%9D%B4%EB%A9%B0-%EC%99%9C-%EC%82%AC%EC%9A%A9%ED%95%A0%EA%B9%8C Entity : https://linuxism.ustd.ip.or.kr/45 JSP : https://gmlwjd9405.github.io/2018/11/03/jsp.html

[관계 이해도]

IOC에서 사용할 객체A를 생성 하려 한다. 이때 DI를 통해 외부에서 객체A와 같은 타입의 객체A를 생성한 뒤 IOC contaner에 주입을 시켜준다. 이때 의존관계가 설정되고 주입된 객체A를 Bean Object라 한다.

1. IOC (제어권의 역전)

객체의 생성, 생명주기의 관리까지 모든 객체에 대한 제어권이 바뀌었다는 것을 의미한다.

2. IOC Contanier

객체에 대한 생성 및 생명주기를 관리할 수 있는 기능

• IoC 컨테이너는 객체의 생성을 책임지고, 의존성을 관리한다.

• POJO의 생성, 초기화, 서비스, 소멸에 대한 권한을 가진다.
• 개발자들이 직접 POJO를 생성할 수 있지만 컨테이너에게 맡긴다. *POJO : 특정 자바 모델이나 기능, 프레임워크 등을 따르지 않은 자바 오브젝트

3. DI

다른 객체를 사용할 때 해당 객체의 외부에서 생성한 의존성이 걸린 객체를 주입한다.

상세한 기능은 다음과 같다.

• IOC가 객체를 생성하려 한다.
• 의존성이 필요한 객체의 멤버변수를 조사한다.
• 의존성이 필요한 객체의 멤버변수와 동일한 타입의 객체를 외부에 생성한다.
• 외부에 생성한 객체를 주입한다.(의존관계를 주입해 주는 것이다.)

4.Bean

Spring IoC 컨테이너가 관리하는 자바 객체를 빈(Bean)이라는 용어로 부른다.

• 우리가 new 연산자로 어떤 객체를 생성했을 때 그 객체는 빈이 아니다.

• ApplicationContext.getBean()으로 얻어질 수 있는 객체는 빈이다.
• Spring에서의 빈은 ApplicationContext가 알고있는 객체 즉, ApplicationContext가 만들어서 그 안에 담고있는 객체를 의미한다.

[참고자료] https://dog-developers.tistory.com/12 https://ko.wikipedia.org/wiki/Plain_Old_Java_Object https://atoz-develop.tistory.com/entry/Spring-%EC%8A%A4%ED%94%84%EB%A7%81-%EB%B9%88Bean%EC%9D%98-%EA%B0%9C%EB%85%90%EA%B3%BC-%EC%83%9D%EC%84%B1-%EC%9B%90%EB%A6%AC

정의 [위키백과]

컴퓨팅에서 무상태 프로토콜(stateless protocol)은 어떠한 이전 요청과도 무관한 각각의 요청을 독립적인 트랜잭션으로 취급하는 통신 프로토콜로, 통신이 독립적인 쌍의 요청과 응답을 이룰 수 있게 하는 방식이다. 무상태 프로토콜은 서버가 복수의 요청 시간대에 각각의 통신 파트너에 대한 세션 정보나 상태 보관을 요구하지 않는다. 반면, 서버의 내부 상태 유지를 요구하는 프로토콜은 상태 프로토콜(stateful protocol)로 부른다.

정리.

Server의 response가 Client와의 세션과 독립적이다 즉, 사용자(브라우저)의 이전 상태 쿠키와 세션 정보를 기록하지 않는 접속을 의미한다. 브라우저가 데이터를 전송할 때마다 연결하고 바로 끊어 버리는 방식이다.

장점.

Server와 Client간의 연결을 계속 유지해 주지 않아 자원의 활용에서 좀더 효율적이다.

단점.

요청 시마다 상태 정보를 전달해야 한다.

Stateful

stateless와 반대로 Server의 response가 계속 연결 되어있어 client의 이전 상태를 기록하고 있는 것이다.

장점.

• 웹서버가 사용자(브라우저)의 상태 client(쿠기) or server(세션) 정보를 기억하고 있다가 유용한 정보로써 활용
• 서버에서 클라이언트 세션을 유지할 필요가 없을 때 서버 리소스를 절약

단점.

• 정보를 저장해 둬야하므로 서버의 무리가 감
• 서버 확장이 어려움
• web, mobile 요청 처리 어려움
• CSRF의 문제 : 세션 보안 문제
• CORS의 문제 : 도메인 리소스 문제
• REST API : Stateless 지향

[출처] https://akdl911215.tistory.com/290 https://junshock5.tistory.com/83

NEW Project Dependencies 설정 (의존성 설정) 의존성을 설정 해 줌으로써 버전을 명시하지 않아도 자동으로 맞는 버전을 가져와준다. Application.java 파일에서 Run을 해준다. http://localhost:8080 에서 다음과 같이 나오면 정상 동작하는 것이다. Auto import 설정해 주기

2. 생성자 만들기

Prac.java, Course.java 파일 생성 생성자 코드 값 매치 확인

3. getter/setter

Course.java코드 getter/setter 설정 및 생성 Tutor.java코드 getter/setter 설정 및 생성 -> Prac.java 실행시 null값 출력 Prac.java 코드 입력 출력 위치를 바꿔주며 해결

4. H2

application.properties에 다음 코드 추가

spring.h2.console.enabled=true spring.datasource.url=jdbc:h2:mem:testdb

Main 재실행 > http://localhost:8080/h2-console > url=jdbc:h2:mem:testdb 확인 > Test Connection > Connect

H2 연결 확인

5. JPA

build.gradle에 다음 코드 추가

implementation 'org.springframework.boot:spring-boot-starter-data-jpa'

6. 상속

Tutor.java에서 Tutor에 Person 상속

SQL이 보이도록 application.properties 세팅 Timestamped.java 생성, Lecture에 Timestamped 상속

>item01Application에 @EnableJpaAuditing 추가 > main 실행 > http://localhost:8080/h2-console 실행 확인

7. CRUD

Create, Read : Repository의 save와 findAll() 활용 > H2 확인 Update1 : LectureService파일 생성 및 Lecture.java 파일 수정 Update2 : Application파일 .update()로 파일 업로드 Delete : deleteAll()

lectureRepository.deleteAll();

8. Lombok

Lombok Setting Lombok Setting (shift 두번 검색) Lombok Setting (Lombok설치)

9. DTO

패키지 및 파일 생성 LectureService 수정전 LectureService 수정후 ( LectureService 생성자 삭제)

10. GET @Getter

Lecture 수정전 Lecture 수정후 ( get함수 다 지우고 @Getter 추가 ) Application 수정전 Application 수정후 @GetMapping, url 입력 추가 실행 ( localhost:8080/api/lectures 접속 ) > GET성공

11. Post @PostMapping

LectureController 수정전 LectureController 수정 @PostMapping, url 추가 Lecture 수정전 Lecture 수정후 (Lecture 생성자 삭제) Postman 실행 (http://localhost:8080/api/lectures) -415에러발생 Postman 415에러 Media Type json으로 변경으로 해결

11. Put @PutMapping

LectureController 수정 @PutMapping, url 추가 Postman 실행 (http://localhost:8080/api/lectures/1) -405에러발생 Postman 405에러 method변경으로 해결

12. DELETE @DeleteMapping

LectureController 수정 @DeleteMapping, url 추가 - 오류 DELETE 수정 완료

AWS 서버리스 프론트엔드-1 강의를 복습하고 정리하느라 TIL을 작성하지 못했지만 그만큼 기록보다는 학습에 온힘을 쏟았다 생각한다.

( 화요일 )

내일배움캠프 D+50

( 수요일 )

내일배움캠프 D+51

( 목요일 )

내일배움캠프 D+52

( 금요일 )

AWS 서버리스 백엔드까지 진도가 나갔지만 이전에 AWS키워드 정리와 실시간 강의를 이해 하는데 있어 신경을 많이 써서 TIL을 작성하지 못했다.

( 토요일 )

오시영 튜터님과 면담을 했다. 나의 면담 내용은 이전에 밀려있는 AWS키워드 정리와 학원에서 주는 강의를 듣기도 해야하고 실시간 강의에서 알려주는 기능을 이해하는데 있어 시간이 너무 오래걸려서 나의 공부방식에 있어 틀린부분이나 미숙한 부분을 여쭤 보았다. 튜터님께서는 일단 키워드 정리는 기능을 반복해서 구현하면서 생기는 의문이나 모르는 부분을 기준으로 키워드를 뽑아 간단하게 정리하고 일단 기능을 익히는게 우선이라 하셨다. 면담이 끝나고 AWS정리는 잠시 내려두고 기능 구현을 해 보았다.

( 일요일 )

현재까지 진행된 기능 구현을 익히고 기록을 해 두었다. 내가 어떤 순서로 어떻게 구현되는지 알기 위해 하나하나 파트가 바뀔 때마다 기록을 해두었고 월요일에 진행하는 기능에 맞춰 TIL에 작성할 예정이다.

한 주 동안 느낀점. 이전에 밀린 부분과 미숙한 부분이 있지만 이번주는 키워드 정리에 너무 많은 신경과 시간을 써서 못했는데 이번 면담을 통해 시간을 좀더 필요한 부분에 집중하고 얼른 끝낸 뒤 이전에 밀린 부분을 해 봐야겠다는 생각을 했다. 잠도 많이 자야겠다... 하루 수면시간 평균 4시간이었던 한주.

연관되어 있는 변수와 메소드를 결합해서 하나의 그룹을 짓는 것.

• 예시를 들어 보면 필통에는 연필, 지우개, 볼펜 등의 필기구 들이 있다.

model

class 필기구 {
    연필();
    지우개();
    볼펜();
}
public class 필통 extends 필기구 {
    필통A.연필()
    필통A.지우개()
    필통A.볼펜()
    //
    필통B.연필()
    필통B.지우개()
    필통B.볼펜()
}

다형성(Doly-mophism)

다형성은 같은 타입이지만 실행 결과가 다양한 객체를 대입할 수 있는 성질. 다중 상속과 비슷하다.

ex)

    Interface Bird{};
    Interface Dog{};
    //
    class animal implements Bird, Dog{}

-> animal 클래스에 Bird와 Dog를 다중으로 상속해 준다.

캡슐화란?

객체의 속성, 메소드를 하나로 묶고 실제 구현 내용을 외부에 감추는 것으로 객체의 무결성을 보장해준다. 쉽게 생각하면 "내부에서 어떤 과정을 거치던 동작만 하면된다."

결합도란?

모듈 간에 상호 의존하는 정도 또는 두 모듈 사이의 연관 관계를 의미한다. ex) 주문하는 고객이 메뉴를 변경하면 직원이 변경된 메뉴에 의해 변화된 행동을 취해야하는 것과 같다.

응집도란?

응집도는 정보 은닉 개념을 확장한 것으로, 명령어나 호출문 등 모듈의 내부 요소들의 서로 관련되어 있는 정도, 즉 모듈이 독립적인 기능으로 정의되어 있는 정도를 의미합니다. ex) 관련된 기능이 합쳐져 있는 것으로 +, -, x, / 기능의 사칙연산 모듈을 생각하면 된다.

인터페이스란?

객체가 각각의 역할과 책임이 있고 메시지로 상호작용해서 협력해 나가는것.

• 설계 객체의 인터페이스는 객체가 수신 할 수 있는 메시지 목록으로 구성됨.
• 객체가 어떤 메시지를 수신 할 수 있는 지가 객체가 제공하는 인터페이스의 모양을 빚는다.
  UI : Program 과 user 의 연결부 (접점) API : Program 과 Program 의 연결부(접점) HTTP API : 데이터 줘! --- (HTTP) --- 그래! JAVA API Doc : Code --- Interface --- Code -> 인터페이스 규칙만 지키면 내부사항, 동작 몰라도 된다. - 캡슐화랑 비슷한 것 같다.

Getter/Setter

Getter: 정보를 가져오는 메소드 Setter: 정보를 바꾸는 메소드

Getter/Setter를 사용하는 이유

객체들의 데이터를 pirvate로 접근을 제한하고, Getter,Setter로만 접근하면 외부로부터 객체를 보호하며 객체의 무결성을 보장해 줄 수 있다.

데메테르의 법칙이란? (Low of Demeter)

기본 개념은 " 정보 은닉 " 원칙에 따라 주어진 객체가 다른 모든 것(하위 구성 요소 포함)의 구조 또는 속성에 대해 가능한 한 적게 가정해야 한다는 것입니다. 즉, 디미터의 법칙은 다른 객체가 어떠한 자료를 갖고 있는지 내부를 몰라야 한다는 것을 의미한다.

RDBMS란?

(Relational Database Management System: 관계형 데이터베이스 관리 시스템) 사용자와 데이터베이스 사이에서 사용자의 요구에 따라 정보를 생성해 주고 데이터베이스를 관리해 주는 소프트웨어

H2 (RDBMS의 소프트웨어 중 하나)

Java SQL 데이터베이스로 초 경량에 인메모리 DB를 지원한다. 인메모리 DB란 서버가 작동하는 동안에만 내용을 저장하고, 서버가 작동을 멈추면 데이터가 모두 삭제되는 데이터베이스를 말한다.

NoSQL (Not Only SQL, No SQL ...)

SQL만을 사용하지 않는 데이터베이스 관리 시스템(DBMS)으로 여러 유형의 데이터베이스를 사용한다.

JPA

SQL을 쓰지 않고 데이터를 생성, 조회, 수정, 삭제할 수 있도록 해주는 번역기.

JDBC

자바에서 데이터베이스에 접속할 수 있도록 하는 자바 API이다. JDBC는 데이터베이스에서 자료를 쿼리하거나 업데이트하는 방법을 제공한다

DI(Dependency Injection : 의존성 주입)

외부에서 두 객체 간의 인터페이스를 사이에 둬서 클래스 레벨에서는 의존관계가 고정되지 않도록 하고 런타임 시에 관계를 주입하여 유연성을 확보하고 결합도를 낮출 수 있게 해준다.

기본틀

Main.java

  public class Main {
      public static void main(String[] args){
      }
  }

자료형

  public class Main {
      public static void main(String[] args){
          //
          // int
          int number = 5;  
          System.out.println(number); // (출력)단축: sout+tab
          //
          // 자료형
          String hello = "Hello sparta"; 
          System.out.println(hello);
          //
          // 상수
          final int finalNumber = 1; 
          System.out.println(finalNumber);
      }
  } 

  public class Main {
      public static void main(String[] args){
          //
          // short: 2 바이트로 표현 가능한 정수형 자료형
          short s = 1;
          System.out.println(s);
          //
          // int: 4 바이트로 표현 가능한 정수형 자료형
          int a = 3;
          System.out.println(a);
          //
          // long: 8 바이트로 표현 가능한 정수형 자료형
          long b= 4;
          System.out.println(b);
          //
          // float: 소수점 표현 가능한 자료형 
          // (뒤에 F를 붙여줘야된다.)
          float f = 5.5F;
          System.out.println(f);
          //
          // double: 좀더 큰 범위의 소수점 표현 가능한 자료형 
          // (뒤에 F를 붙여줘야된다.)
          double d = 5.5F;
          System.out.println(d);
          //
          // 자료형들이 보여줄 수 있는 최대값, 최소값 보기
          System.out.println(Short.MAX_VALUE);
          System.out.println(Short.MIN_VALUE);
          //
          System.out.println(Integer.MAX_VALUE);
          //
          System.out.println(Long.MAX_VALUE);
          //
          System.out.println(Float.MAX_VALUE);
          //
          System.out.println(Double.MAX_VALUE);
      }
  }

  public class Main {
      public static void main(String[] args){
          //
          // 문자 하나를 표현해주는 자료형 (char는 한글자만 가능)
          char c = 'A';
          System.out.println(c);
          //
          // 논리 자료형 (불리언)
          boolean fact = true;
          fact = false;
          System.out.println(fact);
           //
          // 바이트
          byte data = 'd';
          System.out.println(data);
      }
  }

  public class Main {
      public static void main(String[] args){
           //
          int[] intEmptyArray = new int[5]; // 인덱스 방법
          System.out.println(Arrays.toString(intEmptyArray));
          //
          int[] intArray = new int[] {1, 2, 3, 4, 5};
          System.out.println(Arrays.toString(intArray));
          //
          String[] stringEmptyArray = new String[5];
          System.out.println(Arrays.toString(stringEmptyArray));
          //
          String[] season = {"봄", "여름", "가을", "겨울"};
             System.out.println(Arrays.toString(season));
      //
      System.out.println(season[season.length -1]);
      }
  }

연산자

  public class Operator {
      public static void main(String[] args) {
      //
  // 사칙연산
          int num1 = 10;
          int num2 = 5;
      //
          System.out.println(num1 + num2);
          System.out.println(num1 - num2);
          System.out.println(num1 * num2);
          System.out.println(num1 / num2);
          System.out.println(0);
          //
  // 대입 연산자
          int num3 = 10;
          int num4 = 5;
          //
          System.out.println(num3);
          //
          num1 += num4;
          System.out.println(num3); // 15
          //
          num1 -= num4;
          System.out.println(num3); //10
          //
          num1 *= num4;
          System.out.println(num3); //50
          //
          num1 /= num4;
          System.out.println(num3); //10
          //
          num1 %= num4;
          System.out.println(num3); // 0
          //
  // 관계 연산자
          int num5 = 10;
          int num6 = 5;
          System.out.println(num5);
          //
          num5 += num6;
          System.out.println(num5); // 15
          //
          num1 -= num6;
          System.out.println(num5); //10
          //
          num1 *= num6;
          System.out.println(num5); //50
          //
          num1 /= num6;
          System.out.println(num5); //10
          //
          num1 %= num6;
          System.out.println(num5); // 0
          //
  // 논리 연산자
          boolean a = true;
          boolean b = false;
          System.out.println(a && b); // and : 둘 다 참인경우
          System.out.println(a || b); // or
          System.out.println(!b); // NOT
      }
  }

조건문

  // if 문
  public class onditional {
      public static void main(String[] args){
          int check = 100;
          int num1 = 150;
          System.out.println("100보다 큰수 입니다.");
          //
  // switch 문
          char score = 'A';
          System.out.println("A등급 축하합니다.");
          //
  // 삼항 연산자  조건문? True : Fales
          int a= 5;
          String result = "10보다 작습니다.";
          System.out.println(result);
          //
  // for 문
          int sum = 0;
          for ( int i=0; i<10; i++){
              sum += i;
          }
          System.out.println(sum);
          //
  // for ehch 문
          // write your code here
          String[] days = {"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"};
          for(String day : days){
              System.out.println(day);
          }
          //
  // while 문
          int i =0;
          int sum = 0;
          while (i < 10){
              if (i ==4){
                  i++;
                  continue; // i == 4일때 i+1하고 이어서 아래 코드 동작
              }
              sum += (i+1);
              i++;
          }
          System.out.println(sum);
          //
  // do while 문 do 부분을 동작한 후 while문 동작
          int i =0;
          int sum = 0;
          do{
              sum += (i+1);
              i++;
          } while (i < 10){
              if (i ==4){
                  i++;
                  continue; // i == 4일때 i+1하고 이어서 아래 코드 동작
              }
              sum += (i+1);
              i++;
          }
          System.out.println(sum);
      }
  }

객체지향 언어

  class Phone {
      String model;
      String color;
      int price;
  }
  public class object_oriented_language {
      public static void main(String[] args) {
          Phone galaxy = new Phone();
          galaxy.model = "Galaxy10";
          galaxy.color = "Black";
          galaxy.price = 100;
          //
          Phone iphone = new Phone();
          iphone.model = "iPhoneX";
          iphone.color = "Black";
          iphone.price = 200;
          //
          System.out.println("철수는 이번에" + galaxy.model + galaxy.color + " + 색상을 " + galaxy.price + "만원에 샀다.");
          System.out.println("영희는 이번에" + iphone.model + iphone.color + " + 색상을 " + iphone.price + "만원에 샀다.");
      }
  }

  class Calculation {
      int add(int x, int y) {
          return x + y;
      }
      int subtract(int x, int y) {
          return x - y;
      }
  }
  public class object_oriented_language {
      public static void main(String[] args){
          Calculation calculation = new Calculation();
          int addResult = calculation.add(1,2);
          int subtracResult = calculation.subtract(5,3);
          //
          System.out.println(addResult);
          System.out.println(subtracResult);
      }
  }

// 생성자
  class Phone {
      String model;
      String color;
      int price;
      //
      public Phone(String model, String color, int price) {
          this.model = model;
          this.color = color;
          this.price = price;
      }
  }
  public class heritor {
      public static void main(String[] args) {
          Phone galaxy = new Phone("galaxy10", "black", 100);
          Phone iphone =new Phone("iphoneX", "black", 200);
          //
          System.out.println("철수는 이번에 " + galaxy.model + galaxy.color + " + 색상을 " + galaxy.price + "만원에 샀다.");
          System.out.println("영희는 이번에 " + iphone.model + iphone.color + " + 색상을 " + iphone.price + "만원에 샀다.");
      }
  }
  //
  // 생성자를 사용하지 않은 케이스
  //
  class DefaultValueTest {
      byte byteDefaultValue;
      int intDefaultValue;
      short shortDefaultValue;
      long longDefaultValue;
      float floatDefaultValue;
      double doubleDefaultValue;
      boolean booleanDefaultValue;
      String referenceDefaultValue;
  }
  //
  public class heritor {
      public static void main(String[] args) {
          DefaultValueTest defaultValueTest = new DefaultValueTest();
          System.out.println("byte default: " + defaultValueTest.byteDefaultValue);
          System.out.println("short default: " + defaultValueTest.shortDefaultValue);
          System.out.println("int default: " + defaultValueTest.intDefaultValue);
          System.out.println("long default: " + defaultValueTest.longDefaultValue);
          System.out.println("float default: " + defaultValueTest.floatDefaultValue);
          System.out.println("double default: " + defaultValueTest.doubleDefaultValue);
          System.out.println("boolean default: " + defaultValueTest.booleanDefaultValue);
          System.out.println("reference default: " + defaultValueTest.referenceDefaultValue);
      }
  }

  class Animal {
      String name;
      public void cry() {
          System.out.println(name + "is crying.");
      }
  }
  class Dog extends Animal {
      Dog(String name) {
          this.name = name;
      }
      public void swim() {
          System.out.println(name + " is swimming.");
      }
  }
  public class Inheritance {
      public static void main(String[] args) {
          Dog dog = new Dog("코코");
          dog.cry();
          dog.swim();
          //
          Animal dog2 = new Dog("미미");
          dog2.cry();
          dog2.swim();
      }
  }

  public class Inheritance {
      public static void main(String[] args) {
          // write your code here
      }
      int add(int x, int y, int z){
          return x+y+z;
      }
      long add(int a, int b, long c){
          return a+b+c;
      }
      int add(int a, int b){
          return a+b;
      }
  }

  class Animal {
      String name;
      String color;
      public Animal(String name, String color) {
          this.name = name;
      }
      public Animal(String name) {
      }
      @Override
        void cry() {
          System.out.println(name + " is crying");
      }
  }
  class Dog extends Animal {
      public Dog(String name) {
          super(name);
      }
      public void cry() {
          System.out.println(name + " is barking");
      }
  }
  public class Inheritance {
      public static void main(String[] args) {
          Animal dog = new Dog("코코");
          dog.cry();
      }
  }

접근 제어자

  package pkg;
  //
  public class ModifierTest {
      //
      public void messageInside() {
          System.out.println("This is private modifier");
      }
      public void messageOutside() {
          System.out.println("This is public modifier");
          messageOutside();
      }
      public void messageProtected() {
          System.out.println("This is Protected modifier");
      }
      void massagePackagePrivate() {
          System.out.println("This is package private modifier");
      }
  }

  import pkg.ModifierTest;
  //
  class Child extends ModifierTest {
      void callParentProtected() {
          System.out.println("call my parent's protected method");
          super.messageProtected();
      }
  }
  //
  public class access_modifier {
      public static void main(String[] args) {
          ModifierTest modifierTest = new ModifierTest();
          modifierTest.messageOutside();
  //        modifierTest.messageInside();
  //        modifierTest.messageProtected();
  //        modifierTest.massagePackagePrivate();
          //
          Child child = new Child();
          child.callParentProtected();
      }
  }

추상 클래스

  abstract class Bird {
      private int x, y, z;
      //
      void fly(int x, int y, int z) {
          printLocation();
          System.out.println("이동합니다.");
          this.x = x;
          this.y = y;
          if (flyable(z)) {
              this.z = z;
          } else {
              System.out.println("그 높이로는 날 수 없습니다");
          }
          printLocation();
      }
      //
      abstract boolean flyable(int z);
      //
      public void printLocation() {
          System.out.println("현재 위치 (" + x + ", " + y + ", " + z + ")");
      }
  }
  //
  class Pigeon extends Bird {
      @Override
      boolean flyable(int z) {
          return z < 10000;
      }
  }
  //
  class Peacock extends Bird {
      @Override
      boolean flyable(int z) {
          return false;
      }
  }
  //
  public class abstract_class {
      public static void main(String[] args) {
          Bird pigeon = new Pigeon();
          Bird peacock = new Peacock();
          System.out.println("-- 비둘기 --");
          pigeon.fly(1, 1, 3);
          System.out.println("-- 공작새 --");
          peacock.fly(1, 1, 3);
          System.out.println("-- 비둘기 --");
          pigeon.fly(3, 3, 30000);
      }
  }

인터페이스

  abstract class Bird {
      private int x, y, z;
      //
      void fly(int x, int y, int z) {
          printLocation();
          System.out.println("이동합니다.");
          this.x = x;
          this.y = y;
          if (flyable(z)) {
              this.z = z;
          } else {
              System.out.println("그 높이로는 날 수 없습니다");
          }
          printLocation();
      }
      //
      abstract boolean flyable(int z);
      //
      public void printLocation() {
          System.out.println("현재 위치 (" + x + ", " + y + ", " + z + ")");
      }
  }
  //
  class Pigeon extends Bird {
      @Override
      boolean flyable(int z) {
          return z < 10000;
      }
  }
  //
  class Peacock extends Bird {
      @Override
      boolean flyable(int z) {
          return false;
      }
  }
  //
  public class abstract_class {
      public static void main(String[] args) {
          Bird pigeon = new Pigeon();
          Bird peacock = new Peacock();
          System.out.println("-- 비둘기 --");
          pigeon.fly(1, 1, 3);
          System.out.println("-- 공작새 --");
          peacock.fly(1, 1, 3);
          System.out.println("-- 비둘기 --");
          pigeon.fly(3, 3, 30000);
      }
  }

추후 내용 추가 (설명, 동작 이미지, 추가 자바기초 내용)

<과정> (내일배움캠프 D+44 추가)

16. CloudFront

• 생성하기 > Origin domain 설정 > Default root object-potional 설정
• 도메인 이름 확인(브라우저로 열어보기)

17. 도메인 연결

• 가비아 레코드수정 ( 값/위치 : CloudFront 도메인 이름으로 수정)
• 브라우저 확인(www.url.shop: 403에러 )
• CloudFront > 16.에서 생성한 파일 > Settings 수정 > alternate domain name 추가("www.url.shop") > 에러발생

18. 인증서 만들기(Certificate Manager 이용)

• 17.의 Settings > Custom ssl certificate의 Request certificate > 인증서 요청 > 도매인 이름 추가 (*.url.shop) > 검증방법(DNS) > 저장
• 가비아 레코드 추가 > 위 검증에서 값 확인 > 가비아 DNS 레코드 수정 이름(검증): 호스트(가비아), 값(검증): 값/위치(가비아) > 발급확인

19. WAF 만들기

• 설정: Name, Resource type(cloudFront distributions), add AWS resources > Next
• Add rules and rule groups(Default web ACL action for requests that dont't match any rules > Allow 체크) > Next
• Configure metrics > Request sampling options > 검토 > 확인

20. 아이피 차단 룰 추가

• IP sets > 아이피 리스트 생성 > 아이피 추가 (IP set name, ip addresses) > 룰 추가(Add my own rules and rule groups) > Rule type(IP set, Rule(name 설정, IP set)) > 확인
• 테스트 (403 에러)

21. SQL 인젝션 룰 추가

• 룰 추가 (Rule builder 선택 , Rule(name 설정), Statement 설정)
• 테스트 (403 에러)
• 데이터 확인

22. 네임서버 Route53 이전

• Route 53 > DNS 관리 호스팅 영역 생성 > 도메인 이름 설정, 퍼블릭 호스팅 영역, 정보확인(이름서버 4개)

23. 가비아 네임서버 설정

• 관리툴 > 네임서버 확인 > 네임 서버 변경 22번의 4개 > 변경 확인
• 레코드 생성 > 호스팅 영역 세부 정보 > 레코드 생성 > 빠른 레코드 생성 > 확인.