1. "#" 이 나오기전까진 while 반복문을 사용하여야한다.
2. 입력된 string 중에서 모음 (a,e,i,o,u)의 개수를 세어야한다.
3. 대문자 소문자 상관없이 모음의 개수를 세어야한다.

1번을 만족하기 위해 while 반복문을 작성하고 "#"을 입력받으면 반복문이 종료 된다.

while(true) {
    Scanner sc = new Scanner(System.in);
    String str = sc.nextLine();

    if(str.equals("#"))
    break;
}

2번을 만족하기 위해 조건문을 추가해보자. 입력받은 String을 char단위로 점검해가며 모음일 경우 count가 올라간다.

while(true) {
    Scanner sc = new Scanner(System.in);
    String str = sc.nextLine();

    if(str.equals("#"))
    break;

    int count = 0;
       for(int i = 0 ; i < str.length(); i++) {
        if(
        str.charAt(i) == 'a' || 
        str.charAt(i) == 'e' ||
        str.charAt(i) == 'o' ||
        str.charAt(i) == 'i' ||
        str.charAt(i) == 'u')
        count ++;
    }
    System.out.println(count);
}

3번을 만족하기 위해 입력받은 String을 소문자(대문자)로 바꾼다.

while(true) {
    Scanner sc = new Scanner(System.in);
    String str = sc.nextLine();
    str = str.toLowerCase();

    if(str.equals("#"))
    break;

    int count = 0;
       for(int i = 0 ; i < str.length(); i++) {
        if(
        str.charAt(i) == 'a' || 
        str.charAt(i) == 'e' ||
        str.charAt(i) == 'o' ||
        str.charAt(i) == 'i' ||
        str.charAt(i) == 'u') {
        count ++;
        }
    }
    System.out.println(count);
}

정답

import java.util.*;

public class Main {

    public static void main(String[] args) {

        while (true) {
            Scanner sc = new Scanner(System.in);

            String str = sc.nextLine();
            str = str.toLowerCase();

            int count = 0;
            if(str.equals("#"))
                break;

            for (int i = 0; i < str.length(); i++) {
                if(
                str.charAt(i)=='a' ||
                str.charAt(i)=='i' ||
                str.charAt(i)=='o' ||
                str.charAt(i)=='u' ||
                str.charAt(i)=='e'){
                    count++;
                }
            }
            System.out.println(count);
        }
    }
}

<참고>

1. .toLowerCase() : 전부 소문자로 만들기
2. .toUpperCase() : 전부 대문자로 만들기
3. .charAt() : String 타입을 char형태로 바꿔주는 명령어 () 안의 숫자에 해당하는 글자를 반환한다. ex. String str = "안녕하세요" str.charAt(0) == "안"

1. 입력된 값만큼의 줄이 있어야한다.
2. n번째 줄엔 입력된 값 -n 만큼의 공백을 입력해야한다.
3. n번째 줄엔 n개 만큼의 *을 입력해야한다.

우선 1번을 만족하는 for 반복문을 작성해보자.

Scanner sc = new Scanner(System.in);
int a = sc.nextInt();

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

다음은 2번을 만족하는 for 반복문을 내부에 작성해보자.

Scanner sc = new Scanner(System.in);
int a = sc.nextInt();

for(int i = 1; i <= a; i++) {
    for(int j = 1; j <= a - i; j++){
        System.out.println(" ");
    }
    System.out.println();
}

마지막으로 3번을 만족하는 for 반복문을 내부에 작성해보자.

Scanner sc = new Scanner(System.in);
int a = sc.nextInt();

for(int i = 1; i <= a; i++) {
    for(int j = 1; j <= a - i; j++){
        System.out.print(" ");
    }
    for(int k = 1; k <= i; k++){
        System.out.print("*");
    }
    System.out.println();
}

초반에 for문은 하나의 중첩만 가능한 줄 알고 for문을 안으로 안으로 넣었다...

Scanner sc = new Scanner(System.in);
int a = sc.nextInt();

for (int i = 1; i <= a; i++) {
    for (int j = 1; j <= i; j++) {
        for (int k = 1; k <= a - i; k++) {
            if(j > 1) {
                continue;
            }
            System.out.print(" ");
        }
        System.out.print("*");
        }
    System.out.println();
}

이래도 통과되긴 했지만 코드가 한번에 보기 쉽지 않다. for문 안에 여러개의 for문을 사용할 수 있다는 것을 알아두자.

정답

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();

        for(int i = 1; i <= a; i++) {
            for(int j = 1; j <= a - i; j++){
                System.out.print(" ");
            }
            for(int k = 1; k <= i; k++){
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

참고

String값을 입력 받을 경우 : .nextLine(); String의 문자열의 길이를 재는 명령어 : .length();

정답

import java.util.* ;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.nextLine();

        System.out.println(s.length());
    }
}

반복문 기초 문제.

정답

import java.util.*;

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

        Scanner sc = new Scanner(System.in);
        int a;

        a = sc.nextInt();
        for(int i = 1 ; i <= a; i++) {
            System.out.println(i);
        }
    }
}

간단!

1. N을 입력 받는다.
2. 입력받은 N의 수를 구구단의 형태로 출력한다.

import java.util.*;

public class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a;
        a = sc.nextInt();
        for (int i = 1; i < 10; i ++) {
            System.out.println(a + " * " + i + " = " + (a*i));
        }
    }
}

문제가 요구하는 공백을 신경쓰자.

1. 5개의 숫자를 입력 받아야함
2. 각각의 숫자의 제곱을 하고 합을 구해야함
3. 합을 10으로 나눈 나머지를 구해야함

5개의 숫자를 입력 받기.

Scanner sc = new Scanner(System.in);
int[] numbers = new int[5];
for(int i = 0; i < 5; i++) {
  numbers[i] = sc.nextInt();
}

각각의 숫자의 제곱을 하고 합을 구하기.

int sum = 0;

Scanner sc = new Scanner(System.in);
int[] numbers = new int[5];
for(int i = 0; i < 5; i++) {
  numbers[i] = sc.nextInt();
  sum += numbers[i] * numbers[i]
}

합을 10으로 나눈 나머지를 구하기.

int sum = 0;

Scanner sc = new Scanner(System.in);
int[] numbers = new int[5];
for(int i = 0; i < 5; i++) {
  numbers[i] = sc.nextInt();
  sum += numbers[i] * numbers[i]
}

int answer = sum % 10;

정답

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[] numbers = new int[5];
        int sum = 0;

        for(int i = 0; i < 5; i++) {
            numbers[i] = sc.nextInt();
            sum += numbers[i] * numbers[i];
        }

        int answer = sum % 10;
        System.out.println(answer); 
   }
}

중복 for 문을 사용하여 문제를 해결해보자.

첫번째 줄에는 * 이 하나 두번째 줄에는 * 이 두개 (입력받은) N번째 줄에는 * 이 N개 ...

우선 N번째 줄을 설정하는 식을 입력해보자.

Scanner sc = new Scanner(System.in);
int N = sc.nextInt();

for(int a = 1; a <= N; a++) {}

입력받은 N만큼 for문이 반복된다.

그럼 그 안에 N번째 줄에 *을 출력하는 식을 설정해보자.

Scanner sc = new Scanner(System.in);
int N = sc.nextInt();

for(int a = 1; a <= N; a++) {
    for(int j = 1; j <= a; j++) {
        System.out.print("*");
    }
    System.out.println();
}

N번째 줄에서 N만큼의 *이 출력되고 줄바꿈이 되는 것을 알 수 있다

정답

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int N = sc.nextInt();

        for (int i = 1; i <= N; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

_ Int 범위 : -2,147,483,648 ~ 2,147,483,647 _

ㅣN-Mㅣ의 최대값이 Int 의 범위에 벗어나므로 변수에 long을 써야한다.

절대값을 구하는 Math.abs() 를 사용하였다.

정답

package org.example;
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        long a = scanner.nextLong();
        long b = scanner.nextLong();

        System.out.println(Math.abs(a-b));
    }
}

해당 레포지터리가 엔티티와 연결되어 잘 작동하는지 확인해보자.

테스트 파일에 직접 파일을 작성해도 되지만 인텔리J에서 제공하는 단축키인 커멘드+shift+T 를 사용하여 테스트 파일을 생성하였다.
테스트해볼 기능은 다음과 같다.
1. 엔티티에 데이터를 넣었을 때 값이 저장이 되는지. 2. findByName 메서드가 작동을 하는지.

package reproject.calendars.repository;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.transaction.annotation.Transactional;
import reproject.calendars.entity.Calendar;

import java.util.Optional;

import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
import static org.junit.jupiter.api.Assertions.*;

@SpringBootTest 
-> 해당 에너테이션이 있을 시 테스트 실행 시 스프링에 모든 bean이 실행된다.

@ActiveProfiles("test") 
-> application-{profiles}.yml 에서 "" 안의 값을 profiles로 읽는다.
    application-test.yml을 실행하도록 설정한다.

@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
-> 스프링은 기본 실행시 데이터베이스를 embedded모드로 실행시키려한다. 해당 기능을 NONE을 통해 방지하여 
    application-test.yml에 있는 mem모드로 강제로 실행시킨다.

@Transactional
-> 테스트 메서드 하나 실행 시 데이터를 초기화시켜준다.

class CalendarRepositoryTest {

    @Autowired
    private CalendarRepository calendarRepository;

    @Test
    void 캘린더_엔티티_생성() {
        //GIVEN
        Calendar calendar = new Calendar("test", "test");

        //WHEN
        Calendar saveCalendar = calendarRepository.save(calendar);

        //THEN
        assertNotNull(saveCalendar.getId());
        assertEquals("test", saveCalendar.getName());
    }

    @Test
    void findByName_테스트() {
        //GIVEN
        Calendar calendar = new Calendar("test1", "test1");
        calendarRepository.save(calendar);

        //WHEN
        Optional<Calendar> saveCalendar = calendarRepository.findByName("test1");

        //THEN
        assertThat(saveCalendar.isPresent());
        assertThat(saveCalendar.get().getName()).isEqualTo("test1");
        -> Optional로 감싸져 있는 객체는 null값일 수도 있으므로 바로 .getName()을 사용하지 못한다.
            .get()으로 Optional을 한번 벗겨주고 .getName()을 사용해야한다.
    }
}

실제로 test파일이 application-test.yml에서 mem 모드의 데이터베이스를 사용하고 있는지 확인하고 싶다면 application-test.yml에 해당 코드를 추가하자.

logging:
  level:
    org.springframework: DEBUG  # 스프링 관련 로그를 DEBUG 수준으로 출력
    org.hibernate.SQL: DEBUG  # Hibernate가 실행하는 SQL 쿼리 로그 출력

test파일을 실행 후 터미널 로그에서 test를 확인해보자. 검색이 된다면 잘 연결이 된 것이다.

테스트도 무사 통과하였다!

테스트환경 -> application-test.yml / mem 모드로 데이터베이스 설정.

통합 -> application.yml / 두 파일의 공통 코드를 해당 파일에서 설정.

1. application.yml 설정.

spring:
    profiles:
    active: dev -> 따로 에너테이션으로 설정하지 않을시 기본적으로 application-{profiles}.yml 을 불러옴.
                    여기선 profiles를 dev로 설정하였다.

    jpa:
        show-sql: true -> sql을 보여준다.
        database-platform: org.hibernate,dialect.H2Dialect -> h2데이터베이스의 플랫폼 설정.
        hibernate:
            ddl-auto: update -> 어플리케이션 실행 시 자동으로 테이블을 업데이트 해주는 기능.

    h2:
        console:
            enabled: true -> 콘솔(브라우저)에서 h2데이터베이스에 접근할 수 있도록 하는 기능.
            path: /h2-console -> 콘솔(브라우저)에서 localhost:8080/h2-console 으로 h2 접근 가능.

2. application-dev.yml 설정.

spring:
    datasource:
        url: jdbc:h2:~/reproject
        driver-class-name: org.h2.driver
        username: sa
        password: 1

3. application-test.yml 설정.

spring:
    datasource:
        url: jdbc:h2:mem:testdb -> mem방식의 데이터베이스 사용
        driver-class-name: org.h2.driver
        username: sa
        password:

    jpa:
        hibernate:
            ddl-auto: create-drop -> 어플리케이션 종료 시 데이터값 삭제.

• 스프링은 작동 시 기본적으로 application.yml 파일을 확인 후 해당 설정을 적용하고 클래스에서 에너테이션을 확인 후 application-{profiles}.yml 에서 profiles에 따른 yml 파일을 덮어쓴다.

• -test.yml 파일을 사용하려면 클래스에서 @ActiveProfiles("test")를 선언해야한다.

이제 작성한 엔티티와 레포지토리가 실제로 작동하는지 test파일을 만들어볼 것이다.

터미널에서 ./h2.sh 을 실행하여 직접 데이터베이스 어플을 실행시킨다.

• 여러 외부 어플리케이션에서 동일한 db를 공유할 수 있다.
• 서버(h2 어플리케이션)이 꺼지지 않는 한 계속해서 접근할 수 있다. (h2 어플리케이션을 누르면 된다.)

-> yml의 url에서 jdbc:h2:tcp://localhost.. 를 입력해야한다.

** 2. Embedded 모드 - jdbc:h2:~/...**

• H2 데이터베이스가 애플리케이션 내부에서 실행된다.
• 어플리케이션이 종료되면 DB도 같이 종료된다.
• 파일로 저장하여 (tcp도 동일) 어플리케이션 종료 후에도 데이터가 유지 된다.
• tcp보다 처리속도가 빠르다 (네트워크 소켓을 거치지 않기 때문)
• 한 어플리케이션에서만 접근이 가능하다.

3. MEM 모드 - jdbc:h2:mem:...

• H2 데이터베이스를 메모리에서 실행하는 방식.
• 어플리케이션이 종료되면 데이터도 삭제된다.
• 주로 테스트 환경에서 사용한다.
• 어플리케이션 실행 중에만 데이터가 유지된다.

📌 최종 비교표

🚀 결론

운영 환경에서는 TCP(Server) 모드를 사용하여 여러 애플리케이션이 동일한 DB를 공유하도록 설정. 로컬 개발 환경에서는 Embedded 모드를 사용하여 쉽게 데이터베이스를 유지하면서 개발 가능. 테스트 환경에서는 MEM 모드를 사용하여 빠른 테스트 실행과 자동 초기화가 가능.

해당 테이블을 기준으로 calendar 엔티티를 작성하였다.

package reproject.calendars.entity;

import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import java.time.LocalDateTime;

@Entity
@Getter
@NoArgsConstructor
public class Calendar {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private String description;

    private LocalDateTime createdAt;
    private LocalDateTime updatedAt;

    public Calendar(String name, String description) {
        this.name = name;
        this.description = description;
        this.createdAt = LocalDateTime.now();
    }

    public void update(String name, String description) {
        this.name = name;
        this.description = description;
        this.updatedAt = LocalDateTime.now();
    }
}

** @Entity , @Id, @GeneratedValue(strategy = GenerationType.IDENTITY) **

• @Entity 에너테이션이 있을 경우 Pr키를 설정하는 @Id 에너테이션이 필수이다.
• @GeneratedValue(strategy = GenerationType.IDENTITY)
  • 다른 데이터 값이 들어올때 해당 에너테이션이 붙은 값을 자동으로 1씩 올려준다.

** @NoArgsConstructor **

• 자바에선 생성자 생성이 필수이다. 매개변수를 받지 않는 기본 생성자가 있을 시 자동으로 생성자를 만들어준다. 하지만 매개변수를 받는 생성자가 하나라도 있을 시 기본 생성자를 입력을 해주어야 한다.
• 하지만 @NoArgsConstructor 에너테이션이 있을 시 기본 생성자 입력을 하지 않아도 자동으로 스프링에서 해당 에너테이션을 보고 기본 에너테이션을 생성해준다.

• calendar 생성 시 매개변수로 이름과 설명을 받아야하고 메서드를 호출한 시점의 시간을 createdAt에 담는다.
• update 매서드 실행시 이름과 설명을 받고, 메서드를 호출한 시점의 시간을 updatedAt에 담는다.

해당 어플리케이션을 실행하면서 하나의 mv.db파일을 생성하였다.

다른 프로젝트에서 다른 mv.db파일을 사용해야할 경우 새로운 mv.db파일을 만들어야 한다.

맥의 경우 h2 콘솔을 누른 후 Create a new database를 누른다.

다음과 같은 화면이 뜬다.

path에서 ./ 을 입력하면 h2폴더 안에 mv.db파일이 생성된다. ~/ 을 입력하면 user 폴더 안에 mv.db파일이 생성된다.

이렇게 새로운 mv.db파일을 생성하고 관리할 수 있다.

추가

해당 방식으로 데이터베이스를 생성하는 것이 tcp서버 방식인듯 하다.

tcp방식은 h2어플리케이션이 실행되는 동안에는 인텔리J에서 어플을 실행시키지 않아도 데이터베이스를 브라우저에서 h2콘솔에 접근이 가능하다.

기존 embedded 방식은 인텔리J 어플리케이션이 실행될 때에만 h2콘솔에 접근이 가능하다.

yml에서 url에 jdbc:h2:tcp://localhost/~/... 로 명시해주어야 하고,

인텔리J 데이터 베이스 설정에서도 connection type -> remote로 해주어야한다.

기존 embedded 방식에서 url만 바꾸어서 tcp 방식으로 데이터베이스에 접근하도록 변경하였다.

@Entity가 붙은 calendar가 테이블로 등록되어있음을 볼 수 있다. 인텔리J 어플이 꺼져있고 h2 콘솔에 접근하려면 해당 h2어플리케이션을 누르고 H2 Console을 누르면 된다.

인텔리J 어플리케이션이 실행되지 않아도 콘솔에 접근이 가능한 것을 볼 수 있다.

생성된 mv.db파일을 사용할 것인가, 어플리케이션이 작동될 때마다 h2데이터베이스를 생성할 것인가. 고려해봤을 때,

각각의 장단점이 있다.

• 매번 새 데이터를 테스트하고 싶을때 프로젝트를 빠르게 실행하고 초기 데이터를 넣어 테스트할 때 운영 환경이 아닌 개발환경에서만 사용할때 -> 스프링 시작 시 h2 데이터베이스가 생성되도록 설정.

• 기존 데이터(mv.db)를 유지하면서 개발을 이어가야 할 때 프로젝트 재시작 후에도 데이터가 유지되어야 할 때 운영환경과 비슷한 방식으로 개발하고 싶을 때 -> 기존 데이터베이스를 사용. mv.db.

  
  

프로젝트 때에도 어플리케이션 생성 시 db파일이 생성되었던 것 같다. 첫번째 방법으로 진행하자.

개발시엔 어플리케이션 실행시에만 접근이 가능한 embedded 타입으로

첫번째 방법으로 진행하려면 application.yml 파일에 설정값을 입력하여야 한다.

src/main/resources/application.yml

spring:
  datasource:
    url: jdbc:h2:mem:testdb
    driver-class-name: org.h2.Driver
    username: sa
    password:

  jpa:
    show-sql: true
    database-platform: org.hibernate.dialect.H2Dialect
    hibernate:
      ddl-auto: update # 애플리케이션 실행 시 자동으로 테이블 업데이트

  h2:
    console:
      enabled: true
      path: /h2-console

• url : jdbc:h2:mem:testdb

  • mem은 메모리 버전의 테스트 db파일을 사용한다. (어플 중지 시 db가 사라짐)
  • file이나 기존에 있는 db를 tcp방식으로 사용하려면,
    • url : jdbc:h2:file:~/h2-database/testdb
    • url : jdbc:h2:tcp://localhost/~/h2-database/testdb 를 입력하여야 한다.
  • driver-class-name : org.h2.Driver
    • h2드라이버를 사용하겠다는 의미. sql이나 다른 툴을 사용시 해당 코드가 변경되어야 한다.
      

• jpa : database-platforn: org.hibernate.dialect.H2Dialect

  • h2드라이버를 사용하겠다는 의미. sql이나 다른 툴을 사용시 해당 코드가 변경되어야 한다.
  • hibernate: ddl-auto: update
    • 어플리케이션 실행 시 자동으로 테이블이 업데이트가 된다. true, none, 등등 다른 값들이 있지만 나중에 필요하면 알아보자.
      

• h2:

  • console : enable: true
    • 기존 값은 false이다. 브라우저에서 h2 콘솔에 접속하게 해주었다.
  • path: /h2-console
    • localhost:8080/h2-console에 접속 시 h2 콘솔에 접근이 가능하다.

이제 서버 실행 후 브라우저 url에 localhost:8080/h2-console 에 접속 후 url 복붙하면 정상적으로 데이터베이스를 볼 수 있다.

테스트시엔 테스트 실행시 db가 생성되고 테스트가 끝나면 db가 사라지는 mem 방식으로 데이터베이스를 구분하였다.

팀원분이 코드를 설명해달라고 했는데 내가 짠 코드를 설명하지 못하는 상황에 직면..

프로젝트가 끝난 지금 조금 여유가 생겨 적어도 내가 짠 부분의 코드는 알아두고자 하여 처음부터 다시 해보기로 했다.

프로젝트 기획서

1. 프로젝트 개요

• 프로젝트명 : CANBEJ
• 설명: 사용자가 개인 또는 그룹 캘린더를 생성하여 일정을 효율적으로 관리할 수 있는 웹 애플리케이션
• 목표: 사용자가 손쉽게 일정을 추가하고, 수정 및 삭제하며, 다른 사용자와 공유할 수 있는 기능을 제공
  

2. 주요 기능 정리

• 사용자 관리

  • 회원가입 및 로그인 (JWT 인증 적용)

  • 사용자 정보 수정 (닉네임 변경)

  • 비밀번호 변경 및 비밀번호 찾기 기능

• 캘린더 관리 (핵심 기능)

  • 캘린더 생성: 사용자가 새로운 캘린더를 생성할 수 있음

  • 캘린더 조회: 사용자가 소유한 캘린더 목록을 확인할 수 있음

  • 캘린더 수정: 캘린더 이름 및 설명을 수정할 수 있음

  • 캘린더 삭제: 불필요한 캘린더를 삭제할 수 있음

  • 캘린더 공유: 다른 사용자와 캘린더를 공유하고 권한을 설정할 수 있음

• 일정(Schedule) 관리

  • 일정 추가 (제목, 설명, 날짜/시간, 장소 포함)

  • 일정 수정 및 삭제 (캘린더 소유자 및 일정 작성자만 가능)

  • 특정 캘린더의 일정 목록 조회

  • 일정 상세 조회 및 참가자 관리

• 보안 및 인증

  • JWT 기반 로그인/회원가입 구현

  • Spring Security 적용 (API 보안 강화)

  • 비밀번호 암호화 (BCrypt 사용)

우선은 프로젝트 내에서 맡은 파트가 캘린더 파트여서 캘린더 부분을 복기를 해보고 시간이 남으면 나머지도 해보겠슴.

3-1. 캘린더 관리 기능 상세 요구사항 **

• 캘린더 생성

  • 사용자는 캘린더의 이름(name)과 설명(description)을 입력해야 함
  • 생성된 캘린더는 사용자 ID(user_id)와 연결됨
  • 캘린더는 자동으로 생성된 ID(id)를 가짐
  • 생성 시간(created_at)을 자동 저장해야 함
  • 캘린더는 기본적으로 개인 전용(private) 상태이며, 공유 설정을 변경할 수 있음

• 캘린더 조회

  • 사용자는 본인이 소유한 캘린더 목록을 확인할 수 있음
  • 특정 캘린더의 상세 정보를 조회할 수 있음
  • 공유된 캘린더도 함께 조회할 수 있음

• 캘린더 수정

  • 사용자는 이름(name)과 설명(description)을 수정할 수 있음
  • 캘린더 수정 시 수정 시간(updated_at)을 자동 저장해야 함
  • 캘린더 소유자만 수정할 수 있음

• *캘린더 삭제 *

  • 사용자는 자신의 캘린더만 삭제할 수 있음
  • 캘린더 삭제 시, 해당 캘린더에 포함된 일정도 함께 삭제됨
  • 공유된 캘린더를 삭제할 경우, 공유된 사용자에게 알림을 보낼 수 있도록 해야 함

• 캘린더 공유 기능

  • 캘린더 소유자는 다른 사용자를 초대하여 캘린더를 공유할 수 있음
  • 공유된 사용자는 캘린더에 대한 읽기(read) 또는 쓰기(write) 권한을 가질 수 있음
  • 공유된 사용자는 자신의 캘린더 목록에서 확인 가능함
  • 소유자가 공유를 해제하면 해당 사용자 목록에서 캘린더가 사라짐

• 생성된 캘린더가 없을 시 캘린더를 생성하라고 알려줌.

4-1. 캘린더 관리 기능 API 상세 설계

캘린더 생성 HTTP 메서드 : POST URL : /api/calendars

요청

{
 "name": "개인 일정",
  "description": "2024년 개인 일정 관리"
}

반환 성공(201 Created)

{
  "id": 1,
  "name": "개인 일정",
  "description": "2024년 개인 일정 관리",
  "created_at": "2024-02-01T10:00:00"
}

캘린더 조회 HTTP 메서드 : GET URL : /api/calendars

반환 성공(200 OK)

[
  {
    "id": 1,
    "name": "개인 일정",
    "description": "2024년 개인 일정 관리"
  },
  {
    "id": 2,
    "name": "업무 일정",
    "description": "회사 일정 관리"
  }
]

특정 캘린더 조회 HTTP 메서드 : GET URL : /api/calendars/{id}

반환 성공(200 OK)

{
  "id": 1,
  "name": "개인 일정",
  "description": "2024년 개인 일정 관리",
  "created_at": "2024-02-01T10:00:00"
}

캘린더 수정 HTTP 메서드 : POST URL : /api/calendars/{id}

요청

{
  "name": "수정된 일정",
  "description": "업데이트된 일정 정보"
}

반환 성공(200 OK)

{
  "id": 1,
  "name": "수정된 일정",
  "description": "업데이트된 일정 정보",
  "updated_at": "2024-02-01T12:00:00"
}

캘린더 삭제 HTTP 메서드 : DELETE URL : /api/calendars/{id}

반환 성공(200 OK)

{
  "message": "캘린더가 삭제되었습니다."
}

캘린더 공유 HTTP 메서드 : POST URL : /api/calendars/{id}/share

요청

{
  "user_id": 2,
  "permission": "read"
}

반환 성공(200 OK)

{
  "message": "캘린더가 사용자에게 공유되었습니다."
}

5-1. 엔티티 설계

다음은 calendar 클래스를 만들어 보자. 코드를 짜며 개념 정리도 같이 기입하여보자.

정답

SELECT DR_NAME, DR_ID, MCDP_CD, date_format(HIRE_YMD, '%Y-%m-%d') AS HIRE_YMD
FROM DOCTOR
WHERE MCDP_CD = 'CS' OR MCDP_CD = 'GS'
ORDER BY HIRE_YMD DESC, DR_NAME

• DATE_값 처리하기. date_format(칼럼이름, 'sql 연,월,일.. 표기방법')

정답

SELECT MEMBER_ID, MEMBER_NAME, GENDER, date_format(DATE_OF_BIRTH, '%Y-%m-%d') AS DATE_OF_BIRTH
FROM MEMBER_PROFILE
WHERE MONTH(DATE_OF_BIRTH) = '3' AND TLNO IS NOT NULL AND GENDER = 'W'
ORDER BY MEMBER_ID

• DATE_값들 처리하는 방법.

  date_format(칼럼 이름, '연,월,일,,,표기 형식에 따름')

  표기 형식	의미
  %Y	연도(year): 4자리 표현
  %y	연도(year): 뒤에서 2자리 표현
  %a	요일(weekday): 이름 줄임표현
  %W	요일(weekday): 이름
  %w	요일(weekday): 숫자 활용
  %b	월(month): 이름 줄임표현
  %M	월(month): 이름
  %c	월(month): 숫자 표기(자릿수 고정 X)
  %m	월(month): 숫자 표기(자릿수 2개로 고정)
  %D	일(day): 접미사 활용
  %d	일(day): 숫자 활용(1개월 단위)
  %j	일(day): 숫자 활용(1년 단위)
  %p	오전/오후 구분
  ... 등등

• 해당 문제에선 연,월,일 의 정보값만 나타내야하니

• date_format(DATE_OF_BIRTH, '%Y-%m-%d') 를 사용하였다.

정답

SELECT a.FLAVOR 
FROM FIRST_HALF AS a 
LEFT JOIN ICECREAM_INFO AS b 
ON a.FLAVOR = b.FLAVOR
WHERE a.TOTAL_ORDER > 3000 AND b.INGREDIENT_TYPE LIKE 'fruit_based'
ORDER BY a.TOTAL_ORDER DESC;

• LEFT JOIN 이던 INNER JOIN 이던 둘다 정답이다.

정답

SELECT USER_ID, PRODUCT_ID
FROM ONLINE_SALE
GROUP BY USER_ID, PRODUCT_ID
HAVING COUNT(*) >= 2
ORDER BY USER_ID, PRODUCT_ID DESC

• GROUP BY로 USER_ID와 PRODUCT_ID를 하나로 묶었다.
• 묶은 데이터 값이 두번 이상 나올 경우 (COUNT(*)>=2) 의 데이터 값들을 걸러준다.
• USER_ID를 오름차순으로 정렬하였고(ORDER BY), ','를 통해 USER_ID가 같을 경우 PRODUCT_ID는 내림차순으로 정렬하였다.

정답

SELECT ROUND(AVG(DAILY_FEE), 0) AS AVERRAGE_FEE
FROM CAR_RENTAL_COMPANY_CAR
WHERE CAR_TYPE = 'SUV'

• ROUND( a ,int x ) : a의 값을 x번째 소수점자리까지 반올림한다.
• AVG(a) : a의 평균값을 구한다.