아이템 6) 불필요한 객체 생성을 피하라

• 똑같은 기능의 객체를 매번 생성하기보단 객체 하나를 재사용하는 편이 나을 때가 많다.

  String s = new String("apple"); // 따라 하지 말 것!

  String s = "apple"; // 개선된 코드

ex) 주어진 문자열이 유효한 로마 숫자인지를 확인하는 메서드 작성

package step2;

// item6 : 불필요한 객체 생성을 피하라

public class item6_1 {
    // 성능을 훨씬 더 끌어올릴 수 있다
    static boolean isRomanNumeral(String s){
        return s.matches("^(?=.)M*(C[MD]|D?C{0,3})"
                + "(X[CL]|L?X{0,3})(I[XV]|V?I{0,3})$");
    }
}

• String.matches는 정규표현식으로 문자열 형태를 확인하는 가장 쉬운 방법이지만, 성능이 중요한 상황에서 반복해 사용하기엔 적합하지 않다.

package step2;

// item6 : 불필요한 객체 생성을 피하라

import java.util.regex.Pattern;

public class item6_2 {
    // 값비싼 객체를 재사용해 성능을 개선한다.
    public static final Pattern ROMAN = Pattern.compile(
            "^(?=.)M*(C[MD]|D?C{0,3})"
                    + "(X[CL]|L?X{0,3})(I[XV]|V?I{0,3})$"
    );
    static boolean isRomanNumeral(String s){
        return ROMAN.matcher(s).matches();
    }
}

• 이렇게 개선하면 isRomanNumeral이 빈번하게 호출되는 상황에서 성능을 끌어올릴 수있다.

  
  

• Boxing Type 대신 Primitive Type을 권장한다.

• package step2;
  

// item6 : 불필요한 객체 생성을 피하라

public class item6_3 { // Boxing Type private static long sum1(){ Long sum = 0L; for (long i = 0; i < Integer.MAX_VALUE; i++) { sum += i; } return sum; }

// Primitive Type
private static long sum2(){
    long sum = 0L;
    for (long i = 0; i < Integer.MAX_VALUE; i++) {
        sum += i;
    }
    return sum;
}

}

- sum1과 sum2를 비교했을 때 sum2가 약 10배 정도 빠른 실험 결과가 나왔다.
- Boxing된 기본타입보다는 기본타입을 사용하고, 의도치 않은 AutoBoxing을 조심해야한다.

> 아이템 7) 다 쓴 객체 참조를 해제하라

package step2;

// item7 : 다 쓴 객체 참조를 해제하라

import java.util.EmptyStackException;

public class Java_7 { // 제대로 구현한 pop 메서드 public Object pop(){ if (size == 0) throw new EmptyStackException(); Object result = elements[--size]; elements[size] = null; // 다 쓴 참조 해제 return result; } }

-  다 사용한 참조 null 처리 시 이점
    - null 처리한 참조를 실수로 사용하려 하면 프로그램은 즉시 NullPointerException을 던지며 종료된다.


- 하지만 모든 객체를 다 사용하자마자 일일히 null 처리 시 지저분해질 수 있다.

- 객체 참조를 null처리하는 일은 예외적인 경우여야 한다.

- 핵심정리
    - 메모리 누수는 겉으로 잘 드러나지 않아 시스템에 수년간 잠복하는 사례가 있다.
     - 누수는 리뷰코드나 힙 프로파일러 같은 디버깅 도구를 동원해야만 발견되기도 한다.
    - 예방법을 익혀두는게 중요하다.

> item 8) finalizer와 cleaner 사용을 피하라

- Java의 2가지 객체 소멸자
    - finalizer
    - cleaner

- finalizer의 특징
    - 예측불가
    - 상황에 따라 위험할 수 있어 일반적으로 불필요하다.

- cleaner의 특징
    - finalizer의 대안으로 finalizer보다는 덜 위험하다.
    - 예측불가
    - 느리고, 일반적으로 불필요하다.

- finalizer와 cleaner가 할 수 없는 작업과 문제
    - 제때 실행되어야 하는 작업
    - 상태를 영구적으로 수정하는 작업
    - 심각한 성능 문제

- finalizer를 사용한 클래스는 finalizer 공격에 노출되어 심각한 보안문제를 일으킬 수 있다.
    - 객체 생성을 막으려면 생성자에서 예외를 던지는 것만으로도 충분하지만 finalizer가 있다면 그렇지 않다.
    - 해결방안 : final이 아닌 클래스를 finalizer 공격으로부터 방어하려면 아무 일도 하지 않는 finalizer 메서드를 만들고 final로 선언한다.

- finalizer와 cleaner를 대신해줄 방법 : **AutoCloseable**
    - AutoCloseable를 구현하고 크라이언트에서 인스턴스를 다 사용하고 나면 close 메서드를 호출하면 된다.

- 핵심정리
    - cleaner(자바 8까지는 finalizer)는 안전망 역할이나 중요하지 않은 네이티브 자원 회수용으로만 사용
    - 사용 시 불확실성과 성능저하에 주의해야 한다.

> item9) try-finally 보다는 try-with-resources를 사용하라

- 자바 라이브러리에는 close 메서드를 호출해 직접 닫아줘야하는 자원이 많다. ex) InputStream, OutputStream, java.sql.Connection 등

- 자원이 제대로 닫힘을 보장하는 수단으로 try-finally가 쓰이지만 자원을 회수하는 최선의 방법이 아니다.

package step2;

// item9 : try-finally 보다는 try-with-resources를 사용하라

import java.io.*;

public class Java_9_1 { // 자원이 둘 이상이면 try-finally 방식은 지저분하다. static void copy(String src, String dst) throws IOException { InputStream in = new FileInputStream(src); try { OutputStream out = new FileOutputStream(dst); try { byte[] buf = new byte[BUFFER_SIZE]; int n; while ((n = in.read(buf)) >= 0) out.write(buf, 0, n); } finally { out.close(); } } finally { in.close(); } } }

- 다음은 9_1 코드에 try-with-resources를 적용한 모습이다.

package step2;

// item9 : try-finally 보다는 try-with-resources를 사용하라

import java.io.*;

public class Java_9_2 { // try-with-resources 적용 static void copy(String src, String dst) throws IOException {

    try (InputStream in = new FileInputStream(src);
         OutputStream out = new FileOutputStream(dst)) {
        byte[] buf = new byte[BUFFER_SIZE];
        int n;
        while ((n = in.read(buf)) >= 0)
            out.write(buf, 0, n);
    }
}

}

```

• 훨씬 짧고 읽기 수월하며 추후 문제를 찾기에도 좋다.

• 핵심정리

  • 꼭 회수해야하는 자원을 다룰 때는 try-with-resources를 사용
  • 코드는 더 짧고 분명해지고 만들어지는 예외 정보도 훨씬 유용하다.
  • finally가 필요한 상황이면 try-with-resources를 사용

** 이미지출처) Google yes24

아이템 1) 생성자 대신 정적 팩터리 메서드를 고려하라

• 정적 팩터리의 장점
  • 이름을 가질 수 있다.
  • 호출될 때마다 인스턴스를 새로 생성하지는 않아도 된다.
  • 반환 타입의 하위 타입 객체를 반환할 수 있는 능력이 있다.
  • 입력 매개변수에 따라 매번 다른 클래스의 객체를 반환할 수 있다.
  • 정적 팩터리 메서드를 작성하는 시점에는 반환할 객체의 클래스가 존재하지 않아도 된다.
    
• 정적 팩터리의 단점
  • 정적 팩터리 메서드만 제공하면 public이나 protected 생성자가 필요하니 상속받은 클래스를 만들 수 없다.
  • 프로그래머가 인지하기 어렵다.
    
• 핵심정리
  • 정적 팩터리 메서드와 public 생성자는 각자의 쓰임새가 有
  • 상대적인 장단점을 이해 후 사용
  • 정적 팩터리를 사용하는데 유지한 경우가 더 많으므로 무작정 public 생성자를 제공하던 습관은 고치자

아이템 2) 생성자에 매개변수가 많다면 빌더를 고려하라

package step2;

// item2 : 생성자에 대한 매개변수가 많으면 빌더를 고려하라
// 빌더 패턴 - 점층적 생성자 패턴과 자바빈즈 패턴의 장점으로 형성
public class item2 {
    private final int servingSize;
    private final int servings;
    private final int carlories;
    private final int fat;
    private final int sodium;
    private final int carbohyrate;

    public static class Builder{
        // 필수 매개변수
        private final int servingSize;
        private final int servings;

        // 선택 매개변수 - 기본값으로 초기화
        private int calories = 0;
        private int fat = 0;
        private int sodium = 0;
        private int carbohydrate = 0;

        public Builder(int servingSize, int servings){
            this.servingSize = servingSize;
            this.servings =servings;
        }

        public Builder calories(int val)
        {calories = val; return this;}

        public Builder fat(int val)
        {fat = val; return this;}

        public Builder sodium(int val)
        {sodium = val; return this;}

        public Builder carbohydrate(int val)
        {carbohydrate = val; return this;}

        public item2 build(){
            return new item2(this);
        }
        private item2(Builder builder){
            servingSize = builder.servingSize;
            servings = builder.servings;
            calories = builder.calories;
            fat = builder.fat;
            sodium = builder.sodium;
            carbohydrate = builder.carbohydrate;
        }
    }
}

• 핵심정리
  • 생성자나 정적 팩터이가 처리해야 할 매개변수가 많다면 빌더 패턴을 선택하는 게 더 낫다.
  • 매개변수 중 다수가 필수가 아니거나 같은 타입니면 특히 더 그렇다.
  • 빌더는 점층적 생성자보다 클라이언트 코드를 읽고 쓰기가 더 간결하고, 자바빈즈보다 훨씬 안전하다.

아이템 3) private 생성자나 열거 타입으로 싱글턴임을 보증하라

• 싱글턴(singleton)

  • 인스턴스를 오직 하나만 생성할 수 있는 클래스
  • 클래스를 싱글턴으로 만들면 이를 사용하는 클라이언트를 테스트하기 어려워질 수 있다.

• 종류 및 특징

1. public static final 필드 방식
   • 해당 클래스가 싱글턴임이 API에 명백히 드러난다.
   • 간결하다.

     package step2;
     

// item3 : private 생성자나 열거 타입으로 싱글턴임을 보증하라

public class item3_1 { // public static final 필드 방식의 싱글턴 public static final item3_1 INSTANCE = new item3_1(); private item3_1(){}

public void leaveTheBuilding(){}

}

2. 정적 팩터리 방식
    - API를 바꾸지 않고도 싱글턴이 아니게 변경할 수 있다.
    - 정적 팩터리를 제네릭 싱글턴 팩터리로 만들수 있다.
    - 정적 팩터리의 메서드 참조를 공급자(supplier)로 사용할 수 있다.
    - 코드 예시대로라면 가짜 Elvis가 탄생한다. 가짜 Elvis를 예방하고싶다면 Evlis 클래스에 다음의 readResolve 메서드를 추가하면 된다.

package step2;

// item3 : private 생성자나 열거 타입으로 싱글턴임을 보증하라

public class item3_2 { // 정적 팩터리 방식의 싱글턴 public static final item3_2 INSTANCE = new item3_2(); private item3_2(){} public static item3_2 getInstance(){return INSTANCE;}

public void leaveTheBuilding(){}

// 싱글턴임을 보장해주는 readResolve 메서드
private Object readResolve(){
    // '진짜' item3_2를 만들고 가짜 item3_2는 GC에 맡긴다.
    return INSTANCE;
}

}

3. 열거 타입 방식

package step2;

// item3 : private 생성자나 열거 타입으로 싱글턴임을 보증하라

public enum item3_3 { // 열거타입 방식의 싱글턴 INSTANCE;

public void leaveTheBuilding(){}

}

- 핵심정리
    - 조금 부자연스러워 보일 수는 있다.
    - 대부분 상황에서는 원소가 하나뿐인 열거 타입이 싱글턴을 만드는 가장 좋은 방법이다.
    - 단, 만들려는 싱글턴이 Enum 외의 클래스를 상속해야한다면 이 방법은 사용할 수 없다.

>아이템 4) 인스턴스화를 막으려거든 private 생성자를 사용하라

package step2;

// item 4 : 인스터스화를 막으려거든 private 생성자를 사용하라

// 인스턴스를 막을 수 없는 유틸리티 클래스 public class item4 { // 기본 생성자가 만들어지는 것을 막는다.(인스턴스화 방지용) private item4(){ throw new AssertionError(); } // 나머지 코드 생략 }

- 추상 클래스로 만드는 것은 인스턴스화를 막을 수 없다.
→ 하위 클래스를 만들어 인스턴스화하면 된다.

- 해결방안 : private 생성자를 추가하면 클래스의 인스턴스화를 막을 수 있다.

>아이템 5) 자원을 직접 명시하지 말고 의존 객체 주입을 사용하라

- 사용하는 자원에 따라 동작이 달라지는 클래스에는 정적 유틸리티 클래스나 싱글턴 방식이 적합하지 않다.
- 해결방안 : 인스턴스를 생성할 때 생성자에 필요한 자원을 넘겨주는 방식을 사용한다.

package step2;

// item5 : 자원을 직접 명시하지 말고 의존 객체 주입을 사용하라

public class item5 { // 의존 객체 주입은 유연성과 테스트 용이성을 높여준다. private final Lexticon dictionary;

public item5(Lexticon dictionary){
    this.dictionary = Objects.requireNonNull(dictionary);
}
public boolean isValid(String word){}
public List<String> suggestions(String typo){}

}

```

• 핵심정리
  • 클래스가 내부적으로 하나 이상의 자원에 의존하고, 그 자원이 클래스 동작에 영향을 준다면 싱글턴과 정적 유틸리티 클래스는 사용하지 않는 것이 좋다.
  • 이 자원들을 클래스가 직접 만들게 해서도 안된다.
  • 대신 자원을 생성자에 넘겨준다면 의존 객체 주입 방법은 클래스의 유연성, 재사용성, 테스트 용이성을 개선해준다.

** 이미지출처) Google yes24

9-1 애플리케이션 설명

기능 목록

1. 작성 할 기능 목록
   

   NO	기능	설명
   1	등록	퀴즈를 등록
   2	갱신	등록된 퀴즈를 갱신
   3	삭제	등록된 퀴즈를 삭제
   4	목록 표시	등록된 퀴즈의 목록 표시
   5	게임	퀴즈 게임 실시

2. URL 목록

   NO	역할	HTTP메서드	URL
   1	퀴즈 목록 표시	GET	/quiz
   2	등록 처리 실행	POST	/quiz/insert
   3	갱신 화면을 표시	GET	/quiz/{id}
   4	갱신 처리를 실행	POST	/quiz/update
   5	삭제 처리를 실행	POST	/quiz/delete
   6	퀴즈 화면을 표시	GET	/quiz/play
   7	퀴즈 답 체크	POST	/quiz/check

예제 애플리케이션의 레이어

1. 애플리케이션 레이어
   • 클라이언트에서 받은 요청을 제어하고 도메인 레이어를 사용하여 애플리케이션을 제어
     
2. 도메인 레이어
   • 도메인 객체에 대해 애플리케이션의 서비스 처리를 실행
     
3. 인프라스트럭처 레이어
   • 도메인 객체에 대해 CRUD 조작을 해서 데이터의 영속화(데이터를 영구 저장하는)를 담당

레이어별 컴포넌트 설명

• 애플리케이션 레이어

1. Controller

   • 요청을 처리에 매핑하고 결과를 뷰에 넘겨주는 제어를 한다.
   • 주요 처리는 Controller 안에서 실행하지 않고 '도메인레이어'의 Service를 호출한다.
     

2. Form

   • 화면의 폼을 표현한다.
   • 화면에서 입력한 값을 Controller에 넘겨준다.
   • 또한 Controller에서 화면에 결과를 출력 할 때도 사용한다.
   • 도메인 레이어가 애플리케이션 레이어에 의존하지 않도록 Form에서 도메인 객체로 변환하거나 도메인 객체에서 From으로 변환하는 것을 애플리케이션에서 수행해야 한다.
     

3. View

   • 화면 표시를 담당한다.

     
     

• 도메인 레이어

1. 도메인 객체
   • 서비스 처리를 실행할 때 필요한 자원이다.(Entity 등)
     
2. Service
   • 애플리케이션의 서비스 처리를 담당한다.
     
3. Repository
   • Repository는 인터페이스다.
   • 데이터베이스의 데이터 조작 내용만 정의한다.(구현내용은 작성하지 않는다.)
     

• 인프라스트럭처 레이어

1. RepositoryImpl
   • 도메인 레이어에서 정의한 Repository의 구현 클래스이다.
   • 'O/R Mapper'가 Repository의 구현클래스를 생성하는 경우도 있다.
     
2. O/R Mapper
   • O(Object; 객체)와 R(Relational; 관계형 데이터베이스) 간의 데이터를 매핑한다.
     

생성할 컴포넌트 목록

9-2 OX 퀴즈용 데이터베이스 생성 -> 생략

8-1 유효성 검사의 종류

유효성 검사란?

입력내용이 요건에 만족하는지 그 타당성을 확인하는 입력체크

• 단일 항목 검사
• 상관 항목 검사(서로 관련이 있는 항목을 함께 체크하는 방법)

단일 항목 검사란?

입력 항목 하나에 대해 설정하는 입력 체크 기능 from 클래스 등의 필드에 어노테이션을 부여해서 사용한다.

<단일 항목 검사에 이용되는 주요 어노테이션>

<null 체크 어노테이션>

커스텀 유효성 검사란?

단일 항목 검사는 하나의 필드를 체크한다. 여러 필드에 대해 혼합해서 체크하는 것을 상관 항목(서로 관련이 있는 항목) 검사라고 한다.

상관 항목 검사 종류

• Bean Validation을 사용하는 방법
• 스프링 프레임워크에서 제공하는 Validator 인터페이스를 구현하는 방법

8-2 단일 항목 검사를 사용하는 프로그램 만들기 -> 생략

8-3 메세지 관리에 대해 알아보기 -> 생략

8-4 커스텀 유효성 검사기를 사용하는 프로그램 만들기 -> 생략

7-1 요청 파라미터의 종류

요청 파라미터란?

서버에 전송되는 값을 요청 파라미터(request parameter)라고 한다.

• 요청 파라미터의 종류
  • 요청 쿼리 스트링(query string)으로 보내지는 값(GET으로 서버로 데이터 전송)
  • 요청 본문(body)에 저장되어 보내지는 값(POST로 서버로 데이터 전송) ※ 내용 : 뷰에서 입력값 및 선택한 값이나 숨김 파라미터 등에서 미리 뷰에 입력해둔 값 등
  • 뷰에서 클릭한 버튼의 name 속성 값 ※ 내용 : 하나의 뷰에 버튼이 여러 개 있을 때 어느 버튼인지 판별할 수 있는 값
  • URL 경로(path)의 일부로 보내지는 값 ※ 내용 : 링크 등으로 URL의 일부로 보내지는 값

요청 파라미터의 취득 방법

• @RequestParam 사용

  • @RequestParam 어노테이션을 이용해 파라미터를 하나씩 취득

• From 클래스 사용(From 클래스는 따로 만들어야 함)

  • 스프링 MVC가 form 클래스 내의 필드에 대해 값을 저장한다.
  • 요청 파라미터를 모아서 하나의 객체로 받아들이기 때문에 자주 사용되는 방법이다.
  • 받을 때는 '형변환'이나 '포맷 지정'이 가능하다.

7-2 입력값을 받는 프로그램 만들기(@RequestParam) -> 생략

7-3 입력값을 받는 프로그램 만들기(From 클래스) -> 생략

7-4 URL에 포함된 값을 받는 프로그램 만들기 -> 생략

5-1 MVC 모델 알아보기

MVC 모델이란?

• MVC 모델이란 '프로그램의 처리 역할을 나누어서 프로그램을 작성하는 방법'으로 웹 시스템 개발에 자주 사용되고 있다.

• 역할 종류

  • M : 모델(Model)
  • V : 뷰(View)
  • C : 컨트롤러(Controller)

• 모델(Model: M)

  • 시스템에서 비즈니스 로직을 담당한다.
  • 비즈니스 로직이란 시스템의 코어 부분 혹은 시스템의 목적을 처리하는 부분 등으로 해석할 수 있다.
  • 예시) 회원가입시 아이디의 중복확인, 본인인증, 비밀번호 규칙 확인 등

• 뷰(View: V)

  • 한마디로 설명하면 '외형'이다.
  • 사용자 입력과 결과 출력 등 시스템에서 표현 부분을 담당하며 웹 애플리케이션에서는 주로 화면을 담당한다.

• 컨트롤러(Controller: C)

  • 서비스 처리를 담당하는 모델과 화면 표시를 담당하는 뷰를 제어하는 역할을 한다.
  • 사용자가 입력한 내용을 뷰에서 받고 받은 데이터를 기준으로 모델에 내용을 전달한다.
  • 모델에서 받은 데이터를 뷰에 전달해서 화면에 표시하는 역할을 한다.

MVC 모델의 개요와 이점

• 이점
  • 역할 분담을 통해 효율적인 개발 가능
  • 개발하는 엔지니어의 분업화가 용이
  • 설계 변경에 유연하게 대응 가능

5-2 스프링 MVC 알아보기

스프링 MVC란?

• 웹 애플리케이션을 간단하게 만들 수 있는 기능을 제공하는 프레임워크

• 주요 기능 : 화면 전환, 사용자가 사용하는 브라우저와 서버 간의 입출력 데이터 전달을 단순화하는 등

• 구성요소

  • DispatcherServlet : 모든 요청을 수신하는 프런트 컨트롤러
  • Model : 컨트롤러에서 뷰에 넘겨주는 표시용 데이터 등을 저장하는 객체
  • 컨트롤러 : 요청에 대응해서 처리할 내용이 있는 곳
  • 서비스 처리 : 데이터베이스에 접속해서 데이터를 취득하거나 데이터를 가공하는 등 여러 가지 작업을 실행, 개발자가 설계하고 구현한다. (※ 스프링 MVC와 관계없음)
  • 뷰 : 화면 표시 처리를 합니다(구체적으로는 JSP 등의 처리)

요청을 받고 응답을 보낼 때까지의 흐름

1. 모든 요청을 수신하는 프런트 컨트롤러인 DispatcherServlet이 클라이언트로부터 요청을 수신한다.

2. DispatcherServlet이 컨트롤러의 요청 핸들러 메서드를 호출한다.

3. 컨트롤러는 비즈니스 로직 처리를 호출하고, 처리 결과를 받는다.

4. 처리 결과를 모델로 설정하고, 뷰 이름을 반환한다.

5. 반환된 뷰 이름을 받아 DispatcherServlet이 뷰 이름에 대응하는 뷰에 대해 화면 표시 처리를 의뢰한다.

6. 클라이언트가 응답을 받고 브라우저에 화면이 표시된다.

과정이 복잡해보이지만 번거로운 처리는 스프링 MVC가 담당하기 때문에 실제로 작성하는 부분은 컨트롤러, 비즈니스 로직 처리, 뷰의 세 가지뿐인것을 알 수 있다.

5-3 스프링 MVC 사용해보기 -> 생략

4-1 데이터베이스 생성

데이터베이스란?

• 데이터베이스(DataBase)란 데이터를 보관하기 위한 '상자'라고 볼 수 있다.

• 데이터베이스에서 데이터를 모을 때는 특정한 규칙을 적용 후 데이터를 정리해서 보관한다.

• 데이터베이스 = DB

관계형 데이터베이스란?

• 관계형 데이터베이스(Relational DataBase)는 데이터를 표 형식으로 표현하고, 여러 표에서 항목의 값 사이에 관계를 맺고 있는 데이터베이스를 말한다.

• 표 = 테이블(Table)

• 테이블과 테이블 사이의 관계 = Relationship

• 관계형 데이터베이스는 가장 일반적으로 사용되는 데이터베이스라 줄여서 RDB로 불린다.

PostgreSQL로 데이터베이스 확인 -> 생략

4-2 테이블 생성

테이블이란?

• 위에서 테이블은 데이터를 보관하기 위한 상자라고 설명했지만,

• 데이터베이스 안에서 실제로 규칙을 가진 데이터가 저장 되는 상자라고 한다.*

• 테이블은 데이터를 항목으로 해서 이차원 표 형식으로 정리해서 저장한다.

레코드와 칼럼

• 테이블의 가로 행(row) = 레코드(record)
• 하나의 레코드 = 한 건의 데이터
• 테이블의 세로(column) = 칼럼(column)
• 하나의 칼럼 = 데이터의 각 요소

pdAdmin 4로 테이블 생성 -> 생략

4-3 데이터 입력

SQL이란?

• SQL은 데이터베이스를 조작하기 위한 언어이다.

• 정식 명칭 : Structured Query Language

• CRUD란?

  • 영속적으로 데이터를 취급하는 4개의 기본적인 기능의 앞글자를 따서 만든 단어이다.
  • Create : 생성
  • Read : 읽기
  • Update : 갱신
  • Delete : 삭제

• CRUD 명령어, 구문

  • Create : INSERT INTO 테이블명(칼럼명, 칼럼명...) VALUES(값, 값...)
    • Read : SELECT 칼럼명 FROM 테이블명;
  • Update : UPDATAE 테이블명 SET 칼럼명 = 값 WHERE 갱신할_레코드를_특정하는_조건; ※ WHERE로 조건을 지정하지 않는 경우 모든 레코드가 대상이 된다.
  • Delete : DELETE FROM 테이블명 WHERE 삭제할_레코드를_특정하는_조건; ※ WHERE로 조건을 지정하지 않는 경우 모든 레코드가 대상이 된다.

테이블에 데이터 입력 -> 생략

4-4 엔티티와 리포지토리 알아보기

엔티티란?

• 엔티티를 한마디로 표현하면 '데이터를 담아두는 객체'이다.

• 데이터베이스 테이블의 한 행(레코드)에 대응하는 객체이다.

• 엔티티의 필드는 테이블의 한 열(칼럼)에 대응한다.

• 엔티티는 실제 데이터를 담아 두는 개체이다. 사용할 때 다음 세 가지를 기억하자

  • 클래스명 : 클래스명은 대응하는 데이터베이스의 테이블명으로 하는 경우가 많다.
  • 데이터 베이스에 값 넘겨주기 : 데이터베이스에 값을 등록/갱신하는 경우에는 엔티티에 값을 넣어서 넘겨준다.
  • 데이터베이스에서 값 가져오기 : 데이터베이스에서 값을 가져오는 경우에는 값을 엔티티에 넣어서 가져온다.

리포지토리(Repository)란?

• Repository = 데이터베이스를 조작하는 class

• 리포지토리를 생성하려면 반드시 인터페이스를 정의하고 구현해야한다.

  • 이유) 리포지토리 인터페이스의 필드에 리포지토리 구현 클래스를 DI하여 특정 구현에 의존하는 것을 피할 수 있기 때문이다.

• 참고) 자바에서는 인터페이스를 구현한 클래스의 점미사에 'Impl'을 붙이는 경우가 많다.(Impl = implements의 약자)

4-5 스프링 데이터 JDBC 사용해보기

O/R 매퍼란?

• 간단하게 설명하면 애플리케이션에서 사용하는 O(Object) : '객체'와 R(Relational): '관계형 데이터베이스'의 데이터를 매핑하는 것이다.

• O/R 매퍼는 미리 설정된 객체와 관계형 데이터베이스 간의 대응 관계 정보를 가지고 인터페이스의 데이터에 대응하는 테이블에 내보내거나 데이터 베이스에서 값을 읽어 들여 인터페이스에 대입하는 작업을 자동으로 실행한다.

스프링 데이터 JDBC란?

• 스프링 데이터 JDBC = O/R 매퍼

• 스프링 데이터가 제공하는 CrudRepository를 상속해서 자동으로 CRUD를 지원하는 메서드를 사용할 수 있다.

스프링 데이터 JDBC 프로그램 생성 -> 생략

3-1 스프링 프레임워크의 핵심 기능

의존성 주입_첫번째 기능

Dependency Injection으로 약어는 DI, 의존성 주입은 '의존하는 부분을 외부에서 주입하는 것'이다.

다시 말하자면 'DI는 프로그램에서 의존 부분을 외부에서 주입한다'로 이해하면 된다.

관점 지향 프로그래밍_두번째 기능

Aspect Oriented Programming으로 약어는 AOP, AOP는 다음 두 가지 요소로 구성된다.

• 중심적 관심사(Primary Concern) : 실현해야 할 가능을 나타내는 프로그램
• 횡된적 관심사(Crosscultting-Concerns) : 본질적인 기능은 아니지만 품질이나 유지보수 등의 관점에서 반드시 필요한 기능을 나타내는 프로그램

간단히 설명하면 공통 처리 등의 '횡단적 관심사'를 추출하고 프로그램의 여러 곳에서 호출할 수 있게 설정함으로써 개발자는 실현해야 할 기능인

'중심적 관심사'에만 집중해서 작성하면 되는 구조이다.

3-2 DI 컨테이너 알아보기

의존성

어떤 프로그램에 '사용하는 객체'와 '사용되는 객체'의 관계가 있다고 가정해보자

• 사용하는 객체 : A클래스
• 사용되는 객체 : B클래스

A클래스에서 B클래스를 사용하려면 new 키워드를 이용해 B클래스의 인스턴스를 생성하고 B클래스의 메서드를 사용하게 된다.

이때 B클래스에서 구현했던 메서드를 변경하면 그 영향으로 A클래스에서도 메서드를 변경해야한다.

이런 관계를 'A클래스는 B클래스에 의존한다' 라고 한다.

의존성 유형

• 클래스 의존(구현 의존)
• 인터페이스 의존

클래스 의존

• 사용하는 객체 : A클래스
• 사용되는 객체 : B클래스

가정 1) A클래스에서 B클래스의 methodX 메서드를 호출

변경사항) 설계가 변경돼서 '사용되는 객체'를 새롭게 생성된 C클래스로 변경하고 methodY 메서드를 호출하도록 변경해야함

수정사항) A클래스에서 기존 B클래스가 아닌 C클래스 요소로 전부 수정해야함

이렇게 가정 1 처럼 '사용하는 객체' 클래스에서 '사용되는 객체' 클래스 타입을 직접 지정해버리면 '사용되는 객체' 클래스를 변경 할 경우

이를 사용하고 있는 곳을 모두 수정해야한다.

이러한 요소가 한두 군데라면 문제가 없지만 10군데, 100군데 그 이상이 있을 경우 수정 작업과 수정에 의한 테스트 작업이 엄청 늘어난다.

인터페이스 의존

• 사용하는 객체 : A클래스
• 사용되는 객체 : B클래스

가정 2) I 인터페이스가 있고 그것을 구현한 B클래스가 있다. A클래스에서 B클래스의 methodX를 호출한다.

주의할 점) A클래스에서는 인터페이스로 추상화된 I를 이용한다.

변경사항) 설계가 변경돼서 '사용되는 객체'를 새롭게 생성된 C클래스로 변경하고 methodX 메서드를 호출하도록 변경해야함

수정사항) 클래스 의존과 다르게 A클래스의 한 곳만 수정하면 된다.

장점

• 인터페이스는 참조를 받는 유형으로 사용할 수 있으므로 변수의 이름을 변경하지 않아도 된다.
• 인터페이스가 선언된 메서드를 이용하면 클래스가 바뀌어도 메서드명을 변경하지 않아도 된다.

인터페이스에 의존하는 프로그램 만들기 -> 생략

DI 컨테이너

• 의존하는 부분이란 '사용하는 객체' 클래스에 '사용되는 객체' 클래스가 작성된 상태이다.
• 외부로부터 주입이란 '사용하는 객체' 클래스 밖에서 '사용되는 객체' 인스턴스를 주입하는 것이다.

지금까지는 인스턴스를 생성하는데 new 키워드를 사용했지만 인스턴스 생성과 같은 작업을 프레임워크에 맡길 수 있고 그 역할을 하는 것이 DI컨테이너이다.

스프링 프레임워크는 임의로 구현한 클래스를 인스턴스로 만들어주는 기능을 제공한다.

다섯 가지 규칙

1. 인터페이스를 이용하여 의존성을 만든다.
2. 인스턴스를 명시적으로 생성하지 않는다.
3. 어노테이션을 클래스에 부여한다.
4. 스프링 프레임워크에서 인스턴스를 생성한다.
5. 인스턴스를 이용하고 싶은 곳에 어노테이션을 부여한다.

DI 프로그램 만들기 -> 생략

3-3 어노테이션 역할 알아보기

어노테이션을 세 가지 항목으로 설명

1. 어노테이션(annotation)은 주석을 의미하는 영어표현이다.
2. '@xxx'와 같은 형태로 작성한다.
3. 외부 소프트웨어에 필요한 처리 내용을 전달한다.

레이어별로 사용할 인스턴스 생성 어노테이션

애플리케이션을 만들 때는 레이어로 나누는 것이 좋다. 레이어(Layer)는 '층'이라는 의미로, 계층 구조로 되어 있는 각 층을 말한다.

쉽게 설명하자면 복잡한 전체 내용을 한 번에 정리해 이해하지 말고 계층화 해 각 계층별로 대상의 의미를 이해하는 것이다.

• '도메인 주도 설계'(Domain-Driven Design) 레이어 종류
  • 애플리케이션 레이어 : 애플리케이션 레이어는 클라이언트와의 데이터 입출력을 제어하는 레이어이다.

• 도메인 레이어 : 도메인 레이어는 애플리케이션의 중심이 되는 레이어로서 업무 처리를 수행하는 레이어이다.

• 인프라스트럭처 레이어 : 인프라스트럭처 레이어는 데이터베이스에 대한 데이터 영속성 등을 담당하는 레이어이다.

• 레이어별 인스턴스 생성 어노테이션 설명 <주요처리>

  • @Controller : 애플리케이션 레이어의 컨트롤러에 부여
  • @Service : 도메인 레이어의 업무 처리에 부여
  • @Repository : 인프라 레이어의 데이터베이스 액세스 처리에 부여 <보조처리>
  • @Compoenet : @Controller, @Service, @Repository의 용도 이외의 인스턴스 생성 대상 클래스의 부여, 하위 로직을 처리할 때 사용

커스텀 어노테이션

• 커스텀 어노테이션을 만들 때는 jav.lang.Annotation 인터페이스를 상속하고 만든다.
• 커스텀 어노테이션을 정의할 때는 전용 자바 파일을 생성할 필요가 있다.

3-4 AOP(관점 지향 프로그래밍)의 기초지식

AOP 예제

데이터베이스 액세스 처리에는 예외 발생 시 처리하는 내용이 반드시 포함되어야한다.

'구현하고 싶은 프로그램 = 중심적 관심사' '부수적 프로그램 = 횡단적 관심사'

위 2개로 분리하여 프로그램을 작성하는 법을 알아보겠다.

• AOP의 고유 용어

1. 어드바이스(Advice) : 횡단적 관심사의 구현, 로그 출력 및 트랙잭션 제어

2. 에스팩트(Aspect) : 어드라이스를 정리한 것(클래스)

3. 조인포인트(JoinPoint) : 어드바이스를 중심적인 관심사에 적용하는 타이밍. 메서드 실행 전, 메서드 실행 후 등 실행되는 타이밍

4. 포인트컷(Pointcut): 어드바이스를 삽입할 수 있는 위치

5. 인터셉터(Interceptor) : 처리의 제어를 인터셉트하기 위한 구조 또는 프로그램

6. 타깃(Target) : 어드바이스가 도입되는 대상

• 어드바이스의 다섯 가지 종류(어드바이스 이름은 어노테이션과 동일하다)

1. @Before : 중심적 관심사가 실행되기 이전에 횡단적 관심사를 싱행

2. @AfterReturning : 중심적 관심사가 정상적으로 종료된 후에 횡단적 관심사를 실행

3. @AfterThrowing : 중심적 관심사로부터 예외가 던져진 후로 횡단적 관심사를 실행

4. @After : 중심적 관심사의 실행 후에 횡단적 광심사를 실행

5. @Around : 중심적 관심사가 호출 전후에 횡단적 관심사를 실행

포인트컷 식

• execution 지시자의 구문 execute(반환값 패키지.클래스,메서드(인수))

• 와일드 카드

1. *(애스터리스크) : 임의의 문자열, 임의의 패키지 한 계층

2. . .(점두개) : 패키지의 경우 0개 이상의 패키지, 인수의 경우 0개 이상의 인수

3. +(플러스) : 클래스명 뒤에 기술해 클래스와 그 서브클래스 및 구현 클래스를 모두 나타낸다.

AOP 프로그램 만들기 -> 생략

요약

1. AOP에서는 프로그램을 2개의 요소인 중심적 관심사와 횡단적 관심사로 구성되어 있다고 생각한다.

2. 중심적 관심사란 구현해야 할 기능, 비즈니스 로직을 말한다.

3. 횡단적 관심사란 품질이나 유지보수 등의 관점에서 꼭 필요한 기능이다.

4. AOP에서 횡단적 관심사를 분리함으로써 기존 코드를 수정하지 않아도 프로그램 중에 특정 기능(공통 처리)을 추가할 수 있다.

5. 스프링 프레임워크는 다양한 공통 기능을 AOP에서 제공한다.

3-5 Spring Initializr 알아보기 -> 생략

2-1 자바 기초 지식 복습

인터페이스(Interface)란?

자바에서 클래스에 포함하는 메서드의 구체적인 내용을 작성하지 않고 상수와 메서드 타입만 정의한 것

컬렉션(Collection)이란?

복수의 데이터를 더 쉽게 사용할 수 있게 하는 클래스

컬렉션의 종류

• List : 순서대로 데이터를 저장, 데이터의 중복 허용
• Set : 순서를 유지하지 않는 집합, 중복을 허용하지 않음
• Map : 키와 값의 쌍으로 이루어진 데이터 집합, 순서는 유지되지 않고 키의 중복을 허용하지 않으며 값 중복을 허용

List의 주요 구현 클래스(컬렉션 프레임워크에서 제공하는 인터페이스)

• ArrayList : 요소를 배열로 유지, 검색 고속 처리, 요소의 수가 많아지면 추가/삭제 처리시간 多
• LinkedList : 요소끼리 전후 양방향의 링크로 참조하는 리스트 구조를 이용해 관리, ArrayList보다 추가/삭제 처리시간이 빠름, 특정 요소 검색과 같은 인덱스 값에 의한 무작위 액세스에는 적합하지 않음

리스트 프로그램 만들기 → 패스

2-2 웹 애플리케이션 만들기의 필수 지식 확인

클라이언트와 서버

클라이언트 : 서비스를 요청 서버 : 서비스를 제공

즉, 서버가 서비스를 제공해 그 서비스를 클라이언트가 사용하는 관계

브라우저

브라우저란? 인터넷을 사용할 때 이용하는 소프트웨어 Ex) Google Chrome, Firefox, Microsoft Edge, Safari 등등

애플리케이션과 웹 애플리케이션

애플리케이션 = 응용 프로그램 소프트웨어의 약어 즉, 프로그래밍 언어로 작성한 소프트웨어

웹 애플리케이션 = 인터넷을 통해 사용되는 응용 프로그램 Ex) e-커머스, e-러닝 등

웹 서버

웹서버 : 웹 애플리케이션을 배포하는 서버

• 웹서버는 항상 실행되며 클라이언트로부터 액세스(요청)을 계속 기다림

HTTP 통신(프로토콜)

클라이언트와 웹서버는 HTTP 요청(Request)와 HTTP 응답(Response)으로 상호작용 하는 것을 HTTP 통신이라 함(클라이언트의 요청에 대해 웹서버가 응답함)

GET 메서드와 POST 메서드

GET 메서드 : 브라우저에서 웹 서버로 값을 전달할 때 URL 뒤에 값을 더하여 보내는 방식

• URL 뒤에 오는 정보를 '쿼리스트링(query string)' 또는 '쿼리 문자열'이라 함
• URL 끝에 '?'가 붙어 쿼리 스트링의 시작을 나타냄
• 형식은 '이름=값'
• 여러 값을 전달하려면 '&'로 연결

POST 메서드 : 브라우저로부터 웹 서버에 값을 보낼 때 '요청 본문(request body)'이라고 하는 URL에 보이지 않는 장소에 값을 넣어서 보내는 방법

GET 메서드와 POST 메서드의 차이점 명칭으로부터 추측할 수 있음(GET은 받는다, POST는 보낸다) 즉, GET는 지정한 URL에 대한 내용을 받기 위한 메서드, POST는 지정한 URL에 입력 정보를 보내기 위한 메서드

2-3 개발에 사용하는 편리한 라이브러리와 도구

Lombok이란?

프로그램의 세계에서는 편리한 프로그램을 모듈화한 것을 '라이브러리'라고 함 Lombok은 그런 라이브러리 중 하나에 속함

• Lombok을 사용하면 getter와 setter 등의 코드를 작성하지 않아도 자동으로 구현함

Gradle이란?

Gradle은 빌드도구인데 이때 빌드는 '요구된 실행 환경에서 동작할 수 있는 형식에 애플리케이션이나 라이브러리를 조립하는 것' 이라 의미함

빌드도구의 반복적인 작업 자동화

• 필요한 라이브러리를 리포지토리(라이브러리가 저장되어 있는 곳)에서 다운로드 함
• 소스코드를 컴파일함
• 테스트를 실행하여 보고서 출력
• 클래스 파일의 아카이브(여러 파일이나 폴더를 하나로 정리하는 것)를 생성합니다.
• 아카이브를 스테이징 환경(프로덕션 환경에 가까운 환경) 등에 배포합니다.

즉, Gradle은 빌드 파일에서 설정을 작성하는 것으로 여러 가지 작업을 자동으로 해주는 편리한 도구하고 생각하면 됨

1-1 스프링 프레임워크 개요

프레임워크란?

💀소프트웨어나 애플리케이션 개발을 간단하게 해주는 뼈대💀

장단점

장점 : 프레임워크가 개발에 필요한 최소한의 기능을 제공하기 때문에 자신이 모든 기능을 작성 할 필요가 없어 개발에 필요한 시간과 비용을 줄 일 수 있다.

단점 : 프레임워크 고유의 사용법을 이해할 필요가 있다.

스프링 프레임워크란?

자바 개발 환경에서 사용되는 프레임워크 줄여서 스프링이라고도 한다.

스프링 프레임워크의 구성

• 스프링 부트(Spring Boot)
  • 스프링 애플리케이션을 복잡한 설정없이 빠르게 작성하는 기능을 제공

• 스프링 프로젝트(Spring project) 1) 스프링 MVC(Spring MVC) : 웹 애플리케이션을 간단하게 생성하는 기능 제공 2) 스프링 데이터(Spring Data) : 데이터 접근에 관한 기능 제공 3) 스프링 배치(Spring Batch) : 배치 처리 기능 제공 4) 스프링 시큐리티(Spring Security) : 인증/허가 기능 제공

• 스프링 코어 1) 스프링 DI(Spring DI) : 의존성 주입(Dependency Injection) 기능 제공 2) 스프링 AOP(Spring AOP) : 관점 지향 프로그래밍(Aspect Oriented Programming) 기능 제공

1-2 ~ 1-4 개발 환경 준비(자바, IDE, PostgreSQL) → 패스

🤔백엔드 신입 개발자가 쌓아야하는 역량은??

결론부터 말하자면 커뮤니케이션 능력과 문제파악 및 해결능력으로 생각된다. 그리고 제목에도 적었지만 위 능력외에도 쌓아야하는 역량이 더 있다. 자세한 이유는 아래 적어놓았다.

1. 커뮤니케이션 능력

백엔드 개발은 혼자서만 하는 작업이 아니다. 여러 팀과 협력하여 프로젝트를 진행하고, 클라이언트 또는 다른 개발자와 요구사항을 논의해야 한다. 커뮤니케이션 능력은 오해와 혼란을 방지하고, 원활한 협업을 돕는다.

ex) 리뷰 및 피드백 수용, 명확하고 간결한 표현 등

2. 문제파악 및 해결 능력

백엔드 개발은 복잡한 시스템에서 발생하는 다양한 문제를 해결해야한다. 문제를 정확하게 파악하고 효과적인 해결책을 찾는 능력은 필수라고 생각한다.

ex) 디버깅/로깅, 시스템적 사고 등

3 자료구조와 알고리즘

효율적인 코드와 시스템을 설계하기 위해서는 자료구조와 알고리즘에 대한 이해가 필요하다.

• 자료구조 자료구조의 사전적인 정의는 효율적인 접근 및 수정을 가능케 하는 자료의 조직, 관리, 저장을 의미한다. 아래 이미지에 있는 구조들이 전부는 아니지만 큰 틀은 이해해야 코드와 시스템을 설계 할 수있다.

• 알고리즘 알고리즘의 사전적인 정의는 문제 풀이에 필요한 계산 절차 또는 처리 과정의 순서를 뜻한다. 이해를 돕기 위해 아래 간단한 예시인 이미지를 첨부했다.

(이미지출처: 구글)

4. 코딩테스트

위에 나온 자료구조와 알고리즘은 한번에 완성작이 나올 수 없다고 생각한다. 그래서 지금까지 공부한 내용들을 응용하며 연습하는게 좋은 방법이라 할 수 있다. 그게 바로 코딩테스트! 한번 풀었던 문제는 다음번에 풀 때 까먹기 쉬워 여러번 반복하며 복습하는 습관이 중요하다. 온라인으로 문제를 풀 수 있는 사이트가 있으니 코딩테스트로 자료구조와 알고리즘의 역량을 더 기르고 백엔드로 개발자로써 더욱 성장해야겠다.

❔❕ 현재 내 상태는?

직장을 그만두었고 공부에 집중 할 수 있는 시간적 여유가 많다.

✨ 공부계획

AM

• 09:00 ~ 10:00
• • • 기상 및 아침식사**
• 10:00 ~ 11:59
• • • 잠을 깨우는 오전 코딩테스트(1~3문제)🌞**

PM

• 12:00 ~ 01:00
• • • 점심식사**
• 01:00 ~ 06:00
• • • 권장가이드라인 진도 + 자바의 정석_남궁성(추가이해용도)**
• • • 제로베이스 과제**
• 06:00 ~ 09:00
• • • 운동 및 저녁식사**
• 09:00 ~ 11:59
• • • 남은 진도, 과제 및 이해 안갔던 문제와 이론 검토**

💪 백엔드 공부법

처음에는 기초지식이 없어 인터넷 강의와 이론위주로 공부를 했었다. 하지만 이론 위주로 하다가 앞 내용을 잊어버리기 쉬웠다. 그래서 실기로 예제를 따라 적거나 코딩테스트를 직접 풀어보는 방법이 기억에 더 남았다.

이제 시작한지 3주 정도 지났는데 너무 자세한 부분까지 알기에는 벅찬 느낌을 많이 받았다. 그래서 진도도 많이 안나가지는 것 같고 자존감도 떨어졌다.

멘토님이 조언해주신 것 큰 개념위주로 전반적인 흐름을 이해하고 공부를 하는 것이 부담감도 덜고 더 열심히 공부를 할 수 있을 것 같다.

그리고 공부를 하는데에는 기초체력이 정말 중요한 것 같다. 하루종일 컴퓨터 앞에 앉아있으려니 허리가 아파 저녁에 운동은 필수로 해야한다!

💭백엔드 커리어 로드맵

위 이미지는 구글링으로 검색한 이미지이며 일부를 글로 요약해보면 아래와 같다.

1. 프로그래밍 언어와 기본 개념

• 선택한 언어(예: Python, Java, Node.js 등)의 기초 문법 및 개념 이해
• 객체 지향 프로그래밍(OOP) 및 함수형 프로그래밍 개념 숙지

2. 데이터베이스

• 관계형 데이터베이스(SQL)와 NoSQL 데이터베이스(MongoDB, Redis 등) 사용법 이해
• 데이터 모델링과 쿼리 최적화에 대한 기본 지식 습득

3. 웹 개발 기초

• HTTP 프로토콜 및 RESTful API 디자인 이해
• 웹 서버와 웹 애플리케이션의 동작 원리 이해

4. 백엔드 프레임워크와 도구

• 선택한 백엔드 프레임워크(Spring, Express, Django 등) 학습
• 버전 관리 시스템(Git) 사용법 익히기

5. 보안 및 인증

• 사용자 인증 및 권한 관리 구현
• 기본적인 웹 보안 취약점 이해하고 방어 방법 숙지

6. 마이크로서비스 및 컨테이너

• 컨테이너 기술(Docker, Kubernetes)을 이용한 애플리케이션 배포 및 관리 학습
• 마이크로서비스 아키텍처 이해 및 구축 방법 숙지

7. 클라우드 플랫폼

• AWS, Azure, Google Cloud 등의 클라우드 플랫폼 사용법 익히기
• 클라우드 기반 서버 구성과 관리 방법 습득

8. 성능 최적화와 로깅

• 애플리케이션 성능 분석 및 최적화 기법 숙지
• 로깅과 모니터링 도구 활용하여 시스템 상태 관리

9. 테스트와 자동화

• 단위 테스트, 통합 테스트, E2E 테스트 등 테스트 방법 습득
• CI/CD 도구를 사용한 자동화된 빌드, 배포, 테스트 프로세스 구축

🤔나는 어떤 개발자가 되고싶을까?

1. 소통이 잘되는 개발자가 되고싶다. 개발능력이 뛰어나도 소통이 안된다면 완성을 못하는것과 동일하다고 생각하기 때문에 소통이 잘되는 개발자가 되고싶다.

2. 대체되지 않는 개발자가 되고싶다. 위에 보이는 로드맵을 보면 마지막은 계속적인 배움이다. 계속적인 배움을 통해 성장하며 대체되지 않는 개발자가 되고싶다.

문제

입출력 및 예제들

코드 작성

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {

    public static int cnt = 0, target = 0;
    public static int[] output;
    public static boolean isOut = false;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        int num = Integer.parseInt(st.nextToken());
        target = Integer.parseInt(st.nextToken());
        int[] arr = new int[num + 1];
        arr[0] = 0;
        st = new StringTokenizer(br.readLine());
        for (int i = 1; i < arr.length; i++) arr[i] = Integer.parseInt(st.nextToken());
        heapSort(arr);
        if (!isOut) {
            System.out.print(-1);
        }
    }

    public static void swap (int[] arr, int a, int b){
        cnt++;
        int tmp = arr[a];
        arr[a] = arr[b];
        arr[b] = tmp;
        if(cnt == target){
            StringBuilder sb = new StringBuilder();
            for (int i = 1; i < arr.length; i++) {
                sb.append(arr[i]);
                sb.append(" ");
            }
            System.out.print(sb.toString());
            isOut = true;
        }
    }

    public static void heapSort(int[] arr) {
        buildMinHeap(arr, arr.length - 1);
        for (int i = arr.length - 1; i > 1 ; i--) {
            swap(arr, 1 , i);
            heapify(arr, 1, i - 1);
        }
    }

    public static void buildMinHeap(int[] arr, int num) {
        for (int i = num / 2; i >= 1 && !isOut; i--) {
            heapify(arr, i, num);
        }
    }

    public static void heapify(int[] arr, int k, int num) {
        int left = 2 * k;
        int right = 2 * k + 1;
        int smaller = -1;

        if (right <= num) {
            smaller = arr[left] < arr[right] ? left : right;
        } else if (left <= num) {
            smaller = left;
        } else {
            return;
        }

        if (arr[smaller] < arr[k]) {
            swap(arr,k,smaller);
            heapify(arr, smaller, num);
        }
    }
}

Etc

이것도 구글링을 통해 얻은 코드라 gpt의 도움을 받아 해석해보았다..

문제

입출력 및 예제들

코드작성

import java.util.Scanner;
import java.util.LinkedList;
import java.util.Queue;

public class Main {

    public static void main(String[] args) {

        Scanner in = new Scanner(System.in);
        Queue<Integer> q = new LinkedList<>();

        int N = in.nextInt();
        int K = in.nextInt();


        for(int i = 1; i <= N; i++) {
            q.add(i);
        }

        StringBuilder sb = new StringBuilder();
        sb.append('<');

        /*
         *  마지막 부분의 출력은 > 괄호 전에 공백이 없기 때문에
         *  일괄적으로 출력하기 위해 마지막 원소만 남겨질 때까지만
         *  반복하고 마지막 원소는 그대로 출력함
         */

        while(q.size() > 1) {

            for(int i = 0; i < K - 1; i++) {
                int value = q.poll();
                q.offer(value);
            }

            sb.append(q.poll()).append(", ");
        }

        // 마지막 원소 출력한 뒤 > 도 추가
        sb.append(q.poll()).append('>');
        System.out.println(sb);
    }

}

문제

입출력

예제들

코드작성

import java.util.*;

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

        long answer = 1L;

        int n = sc.nextInt();
        int m = sc.nextInt();
        int a = sc.nextInt();
        int h = sc.nextInt();

        for(int i = 0; i < n-1; i ++){
            answer = (answer * m)%1000000007;
        }
        System.out.println(answer);
    }
}

Etc

너무 어려운 것 같아 다른 블로그를 참고했다.. 출처) https://nukoori.tistory.com/40

문제

입출력 및 예제들

코드작성

import.java.util.Arrays;
import java.util.Scanner;

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

    int N = sc.nextInt();
    int[] arr = new int[N];

    for (int i = 0; i < N; i++){
        arr[i] = sc.nextInt();
    }

    // 오름차순 정리
    // 인덱스 첫번째 원소는 최솟값([0]), 마지막원소는 최대값([N-1])
    Arrays.sort(arr);
    System.out.print(arr[0] + " " + arr[N-1]);

    }
}

문제

입출력 및 예제

코드작성

import java.util.LinkedList;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int N = scanner.nextInt(); // 큐의 크기
        int M = scanner.nextInt(); // 뽑아내려는 원소의 개수


        // 1부터 N까지 반복문 실행 후 큐에 순차적으로 1~N까지의 숫자를 추가
        LinkedList<Integer> queue = new LinkedList<>();
        for (int i = 1; i <= N; i++) {
            queue.add(i);
        }

        //  뽑아내려는 원소의 값을 저장할 배열 생성 후 M번 반복하여 뽑아내려는 원소를 입력받고 원소값을 배열에 저장
        int[] targets = new int[M];
        for (int i = 0; i < M; i++) {
            targets[i] = scanner.nextInt();
        }

        // 뽑아내려는 원소들을 하나씩 반복하여 처리 → 무한루프시작
        // 큐에서 뽑아내려는 원소의 인덱스를 찾음
        // 큐의 반 크기를 계산
        int count = 0; // 뽑아내는 횟수를 저장할 변수 초기화
        for (int target : targets) {
            while (true) {
                int index = queue.indexOf(target);
                int halfSize = queue.size() / 2;


                if (queue.getFirst() == target) {
                    queue.pollFirst();
                    break;
                }

                if (index <= halfSize) {
                    queue.addLast(queue.pollFirst());
                } else {
                    queue.addFirst(queue.pollLast());
                }
                count++;
            }
        }
        System.out.println(count);
    }
}

문제

입출력 및 예제들

코드작성

import java.util.Scanner;
import java.util.Stack;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        int[] array = new int[num];
        Stack<Integer>[] a = new Stack[4];

        for (int i = 0; i < num; i++) {
            array[i] = sc.nextInt();
        }

        for (int i = 0; i < 4; i++) {
            a[i] = new Stack<>(); // 스택 배열a의 각각의 스택을 초기화하고
            a[i].push(0); // 0을 push
        }

        // 현재 item이 스택 a[i]의 맨 위의 값보다 크다면, 해당 스택에 'item'을 push
        for (int item : array) {
            for (int i = 0; i < 4; i++) {
                if (item > a[i].peek()) {
                    a[i].push(item);
                    break;
                }
                // 모든 스택에서 현재 숫자 `item`보다 작거나 같은 값을 가진 스택이 없다면, "NO"를 출력하고 프로그램 종료
                if (i == 3 && item <= a[i].peek()) {
                    System.out.println("NO");
                    return;
                }
            }
        }
        System.out.println("YES");
    }
}

• 프론트엔드는 해석 그대로 눈에 보이는 화면(영역)을 구축하고 구현하는 개발자이다.
• 사용언어 : HTML, CSS, JavaScript 등
• Ex)
  • 웹디자인 및 레이아웃, UI개발, 웹 성능 최적화 등

✨백엔드(Back-End)?

• 백엔드도 말 그대로 Back, 보이지 않는 부분(서버관리 등)을 개발, 관리하는 개발자이다.
• 사용언어 : Java, Phython, Ruby, GO, C# 등
• Ex)
  • 서버 개발, 데이터베이스 관리, API 설계 및 개발 등 ✔ 이때 API는 서로 다른 시스템이나 애플리케이션 간에 데이터를 교환하거나 서비스를 요청하고 제공하는데 사용한다.(프론트엔드는 백엔드에게 API를 받아 작업을 한다.)

💭 백엔드 개발자가 되고 싶은 이유

비전공자 + 문과였던 내가 갑자기 개발자가 되고 싶었던 이유는 재직 중 일때 당시 하던 업무의 난이도가 평범하고 미래를 생각 했을 때 금방 대체 될 수 있다고 생각이 들었다. 그래서 주변 지인들 중 개발을 본업으로 갖고 있는 사람들에게 의견을 물어보았다. 나이가 많아져도 실력만 있다면 프리랜서로 활동하며 일을 할 수 있다는 말에 개발에 관심을 갖게 되었다. 개발자는 프론트와 백엔드 말고도 많은 종류가 있는데 그 중에서 백엔드를 고른 이유는 겉으로 보이진 않지만 기능들을 원활하게 진행 시킬 수 있을 때 그 성취감이 좋을 것 같아 선택했다. 배운지 아직 2주도 되지 않았지만 오류가 생겨 해결했을 때 쾌감은 너무 행복한 것 같다. 앞으로도 더 열심히 공부해서 대체되지 않는 개발자가 되고싶다!