버블 정렬은 인접한 두 요소를 비교해서 큰 값을 뒤로 보내는 방식으로 작동합니다. 여러 번 반복하면서 가장 큰 값이 뒤로 가는 정렬입니다.

이제 코드로 구현해 보겠습니다. 코드로 구현 할 때의 핵심은 다로 for문을 어떻게 쓰냐인데요, 한번 살펴보도록 하겠습니다.

📌 문제 버블 정렬

설명

N개이 숫자가 입력되면 오름차순으로 정렬하여 출력하는 프로그램을 작성하세요.

정렬하는 방법은 버블정렬입니다.

입력

첫 번째 줄에 자연수 N(1<=N<=100)이 주어집니다.

두 번째 줄에 N개의 자연수가 공백을 사이에 두고 입력됩니다. 각 자연수는 정수형 범위 안에 있습니다.

출력

오름차순으로 정렬된 수열을 출력합니다.

예시 입력 1

6 13 5 11 7 23 15

예시 출력 1

5 7 11 13 15 23

코드로 살펴보기

public class Main {
    public int[] solution(int n, int arr[]) {
        for(int i = 0; i < n-1; i++) {

            for(int j = 0; j < n-1-i; j++) {
                if(arr[j] > arr[j+1]) {
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }

        return arr;
    }

    public static void main(String[] args) {
        Main T = new Main();
        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();
        }

        for(int i : T.solution(n, arr)) {
            System.out.print(i + " ");
        }
    }
}

✔️ 문제 풀이

N개의 숫자가 입력되면, 이를 버블 정렬을 이용하여 오름차순으로 정렬한 뒤 출력하는 프로그램을 작성합니다.

버블 정렬은 인접한 두 수를 비교하여 왼쪽 수가 오른쪽 수보다 크면 자리를 바꾸는 방식입니다. 이 과정을 반복하면, 가장 큰 수가 점점 오른쪽 끝으로 이동하게 됩니다.

바깥쪽 for문은 전체 배열을 몇 번 반복할지를 나타내며, 배열의 크기가 N이라면 최대 N-1번 반복하면 정렬이 완료됩니다.

안쪽 for문은 이웃한 숫자들끼리 비교하는 부분으로, 한 번 반복할 때마다 가장 큰 수 하나가 뒤로 확정되므로, N - 1 - i까지만 비교하면 됩니다.

버블 정렬은 이중 for문으로 구성되므로, 전체 시간 복잡도는 O(n²) 입니다.

만약 3*(5+2)-9 을 후위연산식으로 표현하면 어떻게 되나요?

3 * (5 + 2) - 9 이라는 중위 표기식을 후위 표기식으로 바꿔보겠습니다. ✅ 중위 표기식: 3 * (5 + 2) - 9 🔄 변환 순서: 괄호 먼저 계산: (5 + 2) → 후위로 바꾸면 5 2 + 그 다음에 3 * (결과) → 3 5 2 + * 마지막으로 - 9 → 3 5 2 + * 9 -

✅ 결과: 후위 표기식 (Postfix) 3 5 2 + * 9 - 💡 후위 표기식의 특징: 괄호가 필요 없음 연산자의 우선순위는 위치로 결정 스택을 이용해서 쉽게 계산할 수 있음

🔄 후위표기 변환 규칙 (정리) 연산자 종류 후위 구조 a + b a b + a * (b + c) a b c + * a * b - c a b * c - a * (b + c) - d a b c + * d -

💬 결론 연산자가 "항상 자신의 피연산자 뒤에 온다"는 말은, 자신이 적용되는 두 값(왼쪽과 오른쪽)이 먼저 나오고, 그 다음 연산자가 온다는 의미입니다.

설명

후위연산식이 주어지면 연산한 결과를 출력하는 프로그램을 작성하세요.

만약 3(5+2)-9 을 후위연산식으로 표현하면 352+9- 로 표현되며 그 결과는 12입니다.

입력

첫 줄에 후위연산식이 주어집니다. 연산식의 길이는 50을 넘지 않습니다.

식은 1~9의 숫자와 +, -, *, / 연산자로만 이루어진다.

출력

연산한 결과를 출력합니다.

예시 입력 1

352+*9-

예시 출력 1

12

public class Main {

    public int solution(String str) {
        int answer = 0;
        Stack<Integer> stack = new Stack<>();

        for(char c : str.toCharArray()) {
            if(Character.isDigit(c)) {
                stack.push(c - 48);

            } else {
                int rt = stack.pop();
                int lt = stack.pop();
                if(c =='+') {
                    stack.push(lt+rt);
                } else if(c=='-') {
                    stack.push(lt-rt);
                } else if(c=='*') {
                    stack.push(lt*rt);
                } else if(c=='/') {
                    stack.push(lt/rt);
                }
            }
        }
        return stack.pop();
    }

    public static void main(String[] args) {
        Main T = new Main();
        Scanner sc = new Scanner(System.in);
        String str = sc.next();
        System.out.println(T.solution(str));
    }
}

프록시는 대리 객체라고도 불린다. 실제 객체 대신 가짜 객체를 먼저 생성해서 필요할 때만 실제 객체에 접근하도록 도와주는 디자인 패턴이다. JPA에서는 데이터베이스 조회 성능 최적화를 위해서 프록시 객체를 사용한다.

📌 JPA에서의 프록시 동작 방식

Member member = em.getReference(Member.class, memberId);

이렇게 호출하면 JPA는 바로 데이터베이스에서 값을 조회하지 않고 프록시 객체만 반환한다.

📌 프록시를 사용해야 하는 이유

✔️ 지연 로딩(Lazy Loading)

• 엔티티의 연관된 데이터를 바로 조회하지 않고, 실제 접근할 때만 DB에 조회 쿼리를 실행한다.
• 즉, 성능 최적화와 메모리 절약 효과가 있다. ✔️ 최소한의 DB 조회 엔티티의 ID 값만 필요하다면 굳이 모든 필드를 조회하지 않고 프록시 객체만 반환한다.

📌 프록시의 내부 구조

• 식별자(ID)만 가지고 있으며, 나머지 필드는 가짜로 채워져 있다.
• 만약, 엔티티의 다른 필드 정보가 더 필요하다면 DB에서 데이터를 조회해서 실제 엔티티 객체를 초기화한다.
• Hibernate는 이를 초기화 트리거 (Lazy Initialozation)라고 한다.

  Member member = em.getReference(Member.class, memberId);
  System.out.println(member.getClass());
  

// 식별자만 조회할 때는 초기화 X System.out.println(member.getId()); // DB 조회 안함

// 다른 필드에 접근하면 DB 조회 발생 (프록시 초기화) System.out.println(member.getUsername()); // DB 조회 발생

![](https://velog.velcdn.com/images/jeong_uk/post/b526e848-70b3-4f99-83d4-5d2c59b12c53/image.png)

#### 프록시 초기화 과정
1. em.getReference() 호출 → 프록시 객체 반환
2. 엔티티의 식별자(ID) 외의 필드 접근 시 → DB 조회 발생 (초기화)
3. 실제 엔티티의 데이터가 프록시 객체의 target 필드에 저장
4. 프록시 객체는 여전히 프록시지만, 내부적으로 실제 엔티티의 데이터를 가진다.

#### 💡 중요한 점
- 초기화 전에는 프록시 객체가 식별자만 가지고 있다.
- 초기화 후에는 프록시 객체가 실제 엔티티 데이터를 target 필드에 보관하지만
타입은 프록시 객체의 타입 그대로 유지된다.

#### 🚨 주의사항
- 프록시 객체는 영속성 컨텍스트가 살아있을 때만 초기화가 가능하다.
- 영속성 컨텍스트가 종료된 상태에서 프록시 객체에 접근하면 LazyInitializationException이 발생한다.
- 프록시 객체는 원본 엔티티를 상속받음, 따라서 타입 체크시 주의해야함 (== 비
교 실패, 대신 instance of 사용)

• 쉽게 말해서 엔티티를 영구 저장하는 환경이라고 생각하면 된다.
• EntityManager.persist(entity);

영속성 컨텍스트의 이점

1. 1차 캐시
2. 동일성(identity) 보장
3. 트랙잭션을 지원하는 쓰기 지연 (transactional write-behind)
4. 변경 감지 (Dirty Checking)
5. 지연 로딩(Lazy Loading)

엔티티를 조회할 때, em.find()를 통해서 조회하게 되는데 위에 사진 처럼 1차 캐시에 없으면 DB에서 조회하여 1차 캐시에 저장하게 된다.

영속성 컨텍스트에 대해서 공부하다가 em.persist(entity)는 데이터베이스에 저장되는게 아니라 영속성 컨텍스트에 반영된다는게 이해가 잘 되지 않아서 코드를 통해서 이해하는게 더 빨랐다.

EntityManager em = emf.createEntityManager();
EntityTransaction tx = em.getTransaction();

tx.begin();  // 트랜잭션 시작

Member member = new Member();
member.setName("이순신");

em.persist(member);  // 영속성 컨텍스트에 등록 (SQL 실행 X)

tx.commit();  // 여기서 flush()가 발생하고, INSERT SQL 실행

✅ persist() → 영속성 컨텍스트에 저장됨 (DB 반영 X) ✅ commit() → flush() 후 DB에 반영됨 ✅ flush() → 변경 내용을 DB에 즉시 반영하지만, 트랜잭션은 유지됨

즉, persist()는 데이터베이스가 아니라 영속성 컨텍스트에 먼저 반영되는 것을 확인할 수 있다! 🚀

의존 관계 주입 방법으로 크게 4가지 방법이 있다.

1. 생성자 주입
2. 수정자 주입(setter 주입)
3. 필드 주입
4. 일반 메서드 주입

생성자 주입

▪️생성자 주입은 생성자를 통해서 의존 관계를 주입 받는 방법을 말한다. ▪️생성자 호출 시점에 딱 1번만 호출히 가능하다. ▪️불변, 필수 의존관계에 사용된다.

@Autowired
public OrderService(MemberRepository memberRepository, MemberService, memberService) {
 this.memberRepository = memberRepository;
 this.memberService = memberService;
    }
 }

생성자가 1개만 있으면 @Autowired는 생략해도 자동으로 주입된다.

수정자 주입(setter 주입)

▪️setter라 불리는 필드의 값을 변경하는 수정자 메서드를 통해서 의존관계를 주입하는 방식이다. ▪️setter메서드를 통해서 선택, 변경 가능성이 있는 의존관계에 사용된다.

@Autowired
public void setMemberRepository(MemberRepository memberRepository){
    this.memberRepository = memberRepository;
}

setXxx, getXxx라는 메서드를 통해서 값을 읽거나 수정하는 규칙을 만들었는데, 이것이 자바빈 프로퍼티 규약이다.

필드 주입

▪️필드에 바로 주입하는 방식이다. ▪️코드가 간결하지만 치명적인 단점으로 외부에서 변경이 불가능해서 테스트하기하 어렵다. ▪️ DI 프레임워크가 없으면 아무것도 할 수 없다. ▪️사용하지 않는 것이 좋다.

@Autowired
private MemberRepository memberRepository

일반 메서드 주입

▪️일반 메서드를 통해서 주입 받을 수 있다. ▪️한번에 여러 필드를 주입 받을 수 있다. ▪️잘 사용하지 않는다.

@Autowired
public void init(MemberRepository memberRepository, MemberService memberService){
    this.memberRepository = memberRepository;
    this.memberService = memberService;
}

@Autowired 옵션 처리

주입할 스프링 빈이 없어도 동작해야 할 때가 있다. 그런게 @Autowired만 사용하면 required 옵션의 기본값이 true로 되어 있어서 자동 주입 대상이 없으면 오류가 발생한다.

▪️저동 주입 대상을 옵션으로 처리하는 방법

@Autowired(required = false)

자동 주입할 대상이 없으면 수정자 메서드 자체가 호출이 안된다.

최신 트랜드의 의존관계 주입

바로 @RequiredArgsConstructor 어노테이션을 사용하는 것이다. ▪️롬북 라이브러리가 제공하는 @RequiredArgsConstructor기능을 사용하면 final이 붙은 필드를 모아서 생성자를 자동으로 만들어준다.

@RequiredArgsConstructor
public class OrderService {
    private final MemberRepository memberRepository
}

정리하면 최근에는 생성자를 딱 1개 두고, @Autowired를 생략하는 방법을 주로 사용한다. 여기에 Lombok 라이브러리의 @RequiredArgsConstructor함께 사용하면 기능은 다 제공하면서, 코드는 깔끔해진다.

CoolSMS와 Redis 소개

이번 문자 인증 기능 구현에 사용할 주요 기술은 CoolSMS와 Redis입니다.

CoolSMS는 카카오 알림톡 및 문자 메시지 발송을 지원하는 REST API 서비스입니다. 이 API를 사용한 이유는 관련 자료가 많아 참고하기 쉽고, 기본적으로 15회 정도 무료로 문자 메시지를 보낼 수 있다는 점이 매우 유용했기 때문입니다.

Redis는 인메모리 기반의 Key-Value NoSQL 데이터베이스로, 데이터를 메모리에 저장하기 때문에 읽기와 쓰기 속도가 매우 빠릅니다. 인증번호와 같은 휘발성 데이터를 저장하기에 적합하며, 데이터의 TTL(Time To Live)을 설정하여 일정 시간 후에 자동으로 삭제할 수 있어 인증번호 관리에 매우 용이합니다.

인증번호는 특성상 오랜 시간 저장할 필요가 없기 때문에, 이러한 휘발성 데이터를 관리하기 위해 Redis를 사용하게 되었습니다. RDMS를 사용할 경우 비효율적이고 복잡한 과정이 필요할 수 있으나, Redis는 간단하고 빠르게 인증번호를 처리할 수 있습니다.

문자 인증 api

문자 인증 기능은 CoolSMS와 Redis를 이용해 구현됩니다. CoolSMS를 통해 인증번호가 담긴 문자 메시지를 발송하고, Redis를 사용하여 인증번호를 저장 및 검증하는 방식입니다.

문자 인증 API 개요

문자 인증 API의 주요 기능은 다음과 같습니다:

1. 인증번호 전송: 사용자가 입력한 전화번호로 인증번호를 전송합니다.
2. 인증번호 검증: 사용자가 입력한 인증번호가 Redis에 저장된 번호와 일치하는지 확인합니다.

AuthService 설명

AuthService 클래스는 CoolSMS와 Redis를 이용하여 문자 인증을 구현합니다. 주요 기능은 다음과 같습니다:

인증번호 생성 및 전송: sendAuthCode() 메서드는 4자리 랜덤 인증번호를 생성하고, 이를 CoolSMS를 통해 사용자의 전화번호로 전송합니다. 이후 Redis에 이 인증번호를 저장하며, 유효기간은 5분으로 설정됩니다. 이는 인증번호가 일정 시간 이후 자동으로 만료되도록 하는데, Redis의 TTL 기능을 활용한 것입니다.

인증번호 검증: validateAuthCode() 메서드는 Redis에 저장된 인증번호와 사용자가 입력한 인증번호를 비교하여 인증 여부를 확인합니다.

@Service
@RequiredArgsConstructor
public class AuthService {

    private final CoolSmsService coolSmsService; // SMS 전송 서비스
    private final RedisTemplate<String, String> redisTemplate; // Redis 템플릿

    public String sendAuthCode(String phoneNumber) throws Exception {
        String authCode = generateRandomNumber(); // 랜덤 인증코드 생성
        String message = "인증번호는 [" + authCode + "] 입니다."; // SMS 내용

        // SMS 전송
        coolSmsService.sendSms(phoneNumber, message);

        // Redis에 인증번호 저장 (유효 기간 5분)
        redisTemplate.opsForValue().set(phoneNumber, authCode, 5, TimeUnit.MINUTES);

        return authCode; // 인증 코드 반환
    }

    public boolean validateAuthCode(String phoneNumber, String authCode) {
            // redis에서 저장된 인증코드 조회
        String storedCode = redisTemplate.opsForValue().get(phoneNumber); // redis의 데이터 조회
        // 저장된 코드와 입력된 코드 비교
        return storedCode != null && storedCode.equals(authCode);
    }

    private String generateRandomNumber() {
        Random rand = new Random();
        StringBuilder numStr = new StringBuilder();
        for (int i = 0; i < 4; i++) { // 4자리 인증번호
            numStr.append(rand.nextInt(10));
        }
        return numStr.toString(); // 생성된 인증번호 문자열로 반환
    }
}

인증번호 전송 화면: 사용자가 전화번호를 입력하고 인증번호를 요청하면, 해당 번호로 인증번호가 전송됩니다. 인증번호 전송 화면: 사용자가 전화번호를 입력하고 인증번호를 요청하면, 해당 번호로 인증번호가 전송됩니다.

정리

CoolSMS와 Redis를 이용하여 문자 인증 기능을 구현하는 과정을 살펴보았습니다. CoolSMS를 통해 쉽게 문자 메시지를 발송하고, Redis의 인메모리 데이터베이스를 활용하여 빠르게 인증번호를 관리함으로써 효율적인 문자 인증 시스템을 구축할 수 있었습니다.

Redis의 인메모리 특성과 TTL 기능은 인증번호와 같은 휘발성 데이터를 관리하는 데 매우 유용하며, 이를 통해 인증번호의 생성, 전송, 검증을 효과적으로 처리할 수 있었습니다. 이번 과정을 통해 REST API 기반의 문자 인증 기능을 손쉽게 구축하는 방법을 배울 수 있었으며, 실무에서도 쉽게 응용할 수 있는 내용이었습니다

AWS(Amazon Web Services)는 아마존(Amazon)의 클라우드 컴퓨팅 사업부입니다. 아마존의 내부 인프라를 관리하는 과정에서 발전시킨 클라우드 기술을 바탕으로 AWS를 론칭하게 됩니다.

AWS는 다양한 클라우드 기반의 제품과 서비스를 제공합니다. 이러한 서비스에는 컴퓨팅 파워, 데이터베이스 스토리지, 콘텐츠 전송 및 기타 기능이 포함됩니다. AWS를 사용함으로써 기업들은 물리적인 서버 구축 없이도 필요한 IT 인프라를 구축하고 운영할 수 있습니다.

왜냐하면 AWS는 유연성, 확장성, 비용 효율성을 제공하기 때문입니다. 기업들은 자신의 필요에 맞게 리소스를 쉽게 확장하거나 축소할 수 있으며, 사용한 만큼만 비용을 지불하게 됩니다.

AWS의 기능

📌 컴퓨팅

1. EC2(Elastic Compute Cloud) Amazon Elastic Compute Cloud(EC2)는 탄력적인 컴퓨팅 서비스이다 빠르고 쉽게 원하는 사양의 서버를 구축,변경,삭제,추가등이 가능하다

2. Lambda AWS Lambda는 이벤트에 대한 응답으로 코드를 실행하고 자동으로 기본 컴퓨팅 리소스를 관리하는 서비스이다. AWS Lambda를 사용하면 서버를 프로비저닝하거나 관리할 필요 없이 코드를 실행할 수 있다.

📌 스토리지

클라우드 서비스의 스토리지는 기본적으로 높은 안정성 과 확장성을 가지고 있다. AWS의 스토리지는 여러곳에 분산되어 저장되기 떄문에 자연재해나 화재에 대해 비교적 안전하다.

📌 모니터링

기본 모니터링과 CloudWatch같은 세부 모니터링을 제공한다.

1. S3 (Simple Storage Services) 여러가지 용도로 사용이 가능한 범용 스토리지 서비스이다. 데이터 보관,정적인 웹 호스팅등등 다양한 형태의 서비스를 할 수 있다.

2. EBS(Elastic Block Storage) 탈부착이 쉽고 기본적으로 기본적으로 SSD를 지원하기떄문에 속도가 빠르다. 예를들어 A인스턴스에 적용한 EBS를 클릭 몇번으로 해제후 안에 들어있는 데이터를 손상없이 그대로 B인스턴스에 적용이 가능하다.

3. Glacier 가격이 저렴하다 다만 성능면에서는 다른 스토리지 서비스보다 떨어진다. 데이터 백업파일 로그기록등등 자주 사용하지 않는 데이터를 보관하기 좋다.

📌 데이터 베이스

AWS의 데이터베이스는 Scaling, Backup, DB Application Path, DB Software linstalls, OS Path, Server maintenance, Stack Power, Network를 관리해주기 때문에에만 집중할 수 있다.

1. RDS MySQL,Microsoft SQL,Oracle,Aurora,MariaDB등 데이터베이스 엔진을 제공한다.

📌 네트워킹

1. Amazon Route 53 DNS를 관리하거나 생성이 가능하다
2. VPC(Virtual Private Cloud) 가상의 사설 네트워크를 구성할 수 있게 만들어주는 기능이다. 네트워크의 접근을 제어할 수 있다(보안 그룹 , 네트워크 ACL), VPN연결 인터넷 게이트웨이 연결

• 가비지 컬렉션은 Heap 영역에 생성된 객체들을 수거하는 것인데 아무 객체나 랜덤으로 수거하지는 않는다. 위의 그림에서 나타나듯이 Method 영역, Stack 영역에서 참조하고 있는 객체들은 제외 대상이고 참조되고 있지 않는 대상들이 수거가 된다.

• Heap 영역은 조금 더 효율적인 운영을 위해서 위와 같이 구조가 분리되어 있다. new 키워드를 이용해서 객체를 생성하면 Eden 영역에 객체가 생성이 된다. 그 후에 Eden 영역이 가득 차게되면 Minor 가비지 컬렉션이 일어나고 살아남을 때마다 age가 올라가게 되고 특정 age가 넘으면 survival 영역에서 old generation 영역으로 이동하게 된다. 그러다가 old generation 부분까지 가득 차게 되면 Major 가비지 컬렉션이 실행되게 된다. 이 때 old generation 영역의 객체 중에 참조되고 있지 않은 객체들을 회수가 된다. 이 때 JVM의 모든 동작이 멈추는데 이를 Stop The World 부른다.

• 가비지 컬렉션은 생각보다 간단한 프로세스로 진행된다. 실제로 내부적으로는 가비지 컬렉션 하는 알고리즘도 존재하는데 등은 버전에 따라 조금씩 다른 것으로 알고 있다. 더 궁금한 내용이 있다면 구글링을 추천한다.

• 생성자 주입
• 수정자 주입 (setter 주입)
• 필드 주입
• 일반 메서드 주입

✔️ 생성자 주입 방식 생성자 주입 방식은 생성자를 통해서 의존관계를 주입 받는 방식입니다. 생성자 방식의 특징은 생성자 호출 시점에 딱 1번만 호출되는 것이 보장되기 때문에 불변객체를 생성하는데 유리합니다.

@Component
public class OrderServiceImpl implements OrderService {
    private final MemberRepository memberRepository;
    private final DiscountPolicy discountPolicy;

 @Autowired // 생성자 주입 방식
 public OrderServiceImpl(MemberRepository memberRepository, DiscountPolicy
discountPolicy) {
    this.memberRepository = memberRepository;
    this.discountPolicy = discountPolicy;
    }
}

✔️ 수정자 주입 방식 수정자 주입 방식은 setter라 불리는 필드의 값을 변경하는 수정자 메서드를 통해서 의존관계를 주입하는 방법입니다. 주로 변경 가능이 있는 의존관계를 주입하는데 사용됩니다.

@Component
public class OrderServiceImpl implements OrderService {
    private MemberRepository memberRepository;
    private DiscountPolicy discountPolicy;

 @Autowired // 수정자 주입 방식
 public void setMemberRepository(MemberRepository memberRepository) {
    this.memberRepository = memberRepository;
 }

 @Autowired // 수정자 주입 방식
 public void setDiscountPolicy(DiscountPolicy discountPolicy) {
    this.discountPolicy = discountPolicy;
    }
}

✔️ 필드 주입 필드 주입 방식은 코드가 간결해서 좋아보이지만, 외부에서 변경이 불가능해서 테스트하기 힘들다는 단점이 있습니다. 필드 주입 방식은 이러한 이유 때문에 사용하지 않는 것이 좋습니다.

@Component
public class OrderServiceImpl implements OrderService {
    @Autowired // 필드 주입 방식
    private MemberRepository memberRepository;
    @Autowired // 필드 주입 방식
    private DiscountPolicy discountPolicy;
}

✔️ 일반 메서드 주입 일반 메서드 주입 방식은 일반 메서드를 통해서 주입받는 방식입니다. 한번에 여러 필드를 주입받을 수 있는 장점이 있지만 일반적으로 잘 사용하지 않는 방식입니다.

@Component
public class OrderServiceImpl implements OrderService {
    private MemberRepository memberRepository;
    private DiscountPolicy discountPolicy;

@Autowired
public void init(MemberRepository memberRepository, DiscountPolicy
discountPolicy) {
    this.memberRepository = memberRepository;
    this.discountPolicy = discountPolicy;
    }
}

그렇다면 왜 생성자 주입 방식을 사용해야 할까?

위 4가지 방식중에서는 필드 주입이 가장 편해 보이지만, 최근에는 DI 프레임워크 대부분이 생성자 주입방식을 권장하고 있습니다.

• 대부분의 의존관계 주입은 한번 일어나면 종료시점까지 의존관계를 변경할 일이 없습니다. (대부분 불변하게 설계하기 때문에)
• 수정자 주입이나, 일반 메서드 주입 방식은 메서드를 사용해야 하므로 public으로 열어두어야 합니다.
• 실수로 변경할 수 있기 때문에 변경하면 안되는 메서드를 열어두는 것은 좋은 설계 방법이 아닙니다.
• 하지만 생성자 주입 방식은 객체를 생성할 때 1번만 호출되기 때문에 불변하게 설계할 수 있습니다.
• 기본으로 생성자 주입을 하고 필요 할 때 수정자 주입 방식을 옵션으로 부여하는 방식으로 코드를 작성해야 합니다.

Problem 모르는 부분이 많아서 이해하는 시간이 많이 필요했고, Spring에 대한 공부가 많이 필요하다고 느꼈음. 새로운 부분을 배우게 되면 낯설다고 두려워하지말기!

Try 멋사 과제를 하면서 운영진분들이 comment로 알려준 방법대로 하면서 코드를 작성해 나아가면 더 나은 코드를 작성하게 될 것 같다. 백준이나 프로그래머스 알고리즘을 풀면서 자신만의 코딩스타일이 생기면서 실력을 기르면 좋을 것 같다.

자바에서는 함수를 메서드(Method)라 한다. 메서드를 사용하는 이유는 무엇일까? 바로 코드의 중복을 제거해 준다는 것이다. 코드를 통해서 살펴 보도록 하자.

간단하게 변수 두개를 더해서 출력해주는 기능을 개발해보자.

package method;
public class Method1 {
 public static void main(String[] args) {
 //계산1
 int a = 50;
 int b = 50;
 System.out.println(a + "+" + b + " 연산 수행");
 int sum1 = a + b;
 System.out.println("결과1 출력:" + sum1);
 //계산2
 int x = 10; // 중복
 int y = 20; // 중복
 System.out.println(x + "+" + y + " 연산 수행"); // 중복
 int sum2 = x + y; // 중복
 System.out.println("결과2 출력:" + sum2); // 중복
 }
}

위 코드의 문제점은 과연 무엇일까? 만약 프로그램에서 이와 같은 계산을 반복해야 한다면 어떨 것인가? 위 코드처럼 코드의 중복이 많아 질 것이다. 이런 문제들을 해결해 준 것이 바로 메서드(Method)이다.

그럼 메서드(Method)를 사용해서 코드를 작성해 보도록 하자.

package method;

public class Method1Ref {
    public static void main(String[] args) {
        //계산1
        int sum = add(5,10);
        System.out.println("결과1 출력:" + sum);
        //계산2
        int sum2 = add(10,100);
        System.out.println("결과2 출력:" + sum2);
    }

    //add 메서드
    public static int add(int a, int b) {
        System.out.println(a + "+" + b + " 연산 수행");
        int sum = a+b;
        return sum;
    }
}

메서드 선언(Method Declaration)

public static int add(int a, int b)

add 는 메서드의 선언 부분으로 메서드의 이름과 반환 타입, 매개변수를 포함한다. 메서드의 이름은 add로 자신이 기능을 수행할 때 이름을 정해주면 된다.

int 반환 타입은 Return Type으로 메서드의 실행 결과를 반활 할때 타입을 정해주는 것이다.

매개변수는 (int a, int b)로 메서드를 호출할 때 전달되는 입력값을 말한다.

메서드 호출

앞에서 정의한 메서드를 실행하려면 이름에 입력값을 전달하면 된다.

int sum = add(5,10);

파라미터 변수 a에는 5가 전달되고 b에는 10이 전달되면서 메서드가 실행되고, return을 사용해서 메서드의 실행 결과인 sum을 반환함으로써 15가 출력되는 것이다.

참고로 return 타입이 없을 때에는 void를 사용해야 한다.

배열은 동일한 자료형(Data Type) 변수를 사용해기 위해 데이터를 연속된 공간에 저장하는 자료구조이다.

그렇다면 배열을 사용하는 이유는 무엇일까? 코드를 통해서 비교해보자.

만약 위에 코드처럼 학생을 몇 명 더 추가해야 한다면 변수를 선언하는 부분과 점수를 철력하는 부분의 코드도 추가해야 한다. 학생 수가 증가함에 따라 int형 변수도 선언해야 한다.

위 코드는 배열을 사용함으로써 코드가 얼마나 줄었는지 확인할 수 있다.

이렇게 같은 타입의 변수를 반복해서 선언하고 반복해서 사용하는 문제를 해결한 것이 바로 배열이다.

배열 선언 및 사용

배열을 정의 하는 방법은 크게 2가지 방법이 있다.

자료형[] 변수 = {데이터1, 데이터2, 데이터3, ... };

이 방법은 데이터들의 값을 알고 있을 때 사용하면 편리하다. 앞에서 작성한 코드와 같은 방법이다. 예를 들어 1반에 있는 학생들의 점수를 저장한다고 가정해보자. 위에 비유한 내용으로 배열을 생성하는 예제를 살펴보자

public class ArrayEx {
    public static void main(String[] args) {
        int[] students = {50, 60, 70, 80, 90};
            // 인덱스 번호 :0 , 1 , 2 , 3 , 4 

            // 변수 값 사용
        System.out.println(students[0]);
        System.out.println(students[1]); 
        System.out.println(students[2]); 
        System.out.println(students[3]); 
        System.out.println(students[4]);
    }
}

students라는 int[] 변수에 데이터를 저장하였다. 먼저 여기서 알아야 할 것은 바로 인덱스(index)이다. 인덱스는 데이터를 저장한 순서0 부터 시작하여 1씩 증가되어 만들어진다. 즉, students라는 배열에 0번부터 4번까지의 index 번호를 가진 5개의 공간이 데이터들이 저장되어 있는 것이다.

두번째 정의하는 방벙은 아래와 같다.

자료형[] 변수 = new 자료형[배열크기]
변수[0] = 데이터 값;
변수[1] = 데이터 값;

위 방법은 배열의 값은 모르지만 향후 값을 저장하고 싶을 때 주로 사용되는 방법이다. new라는 연산자를 통해서 참조형 변수를 생성하게 되는데 아래 사진처럼 x001과 같은 특정 주소값을 가지게 된다. (실제로는 16진수로 나타나는 주소값을 가진다.)

new 연산자를 사용해서 배열을 작성해 보도록 하자.

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

 int[] students = new int[5]; //배열 생성
 //변수 값 대입
 students[0] = 90;
 students[1] = 80;
 students[2] = 70;
 students[3] = 60;
 students[4] = 50;
 //변수 값 사용
 System.out.println("학생1 점수: " + students[0]);
 System.out.println("학생2 점수: " + students[1]);
 System.out.println("학생3 점수: " + students[2]);
 System.out.println("학생4 점수: " + students[3]);
 System.out.println("학생5 점수: " + students[4]);
 }
}

new는 새로 생성한다는 뜻이고, int[5]는 int형 변수 5개라는 뜻이다. 따라서 int형 변수 5개룰 다룰 수 있는 배열이 생기게 된 것이다.

이제 배열에 대한 간단한 문제를 풀어보도록 하자.

학생5명의 점수를 합산해 평균을 내는 프로그램을 작성해 보도록 하자.

public class ArrayEx1 {
 public static void main(String[] args) {
 int student1 = 90;
 int student2 = 80;
 int student3 = 70;
 int student4 = 60;
 int student5 = 50;
 int total = student1 + student2 + student3 + student4 + student5;
 double average = (double) total / 5;
 System.out.println("점수 총합: " + total);
 System.out.println("점수 평균: " + average);
 }
}

사용자의 입력을 받기 위해서는 Scanner가 필요하다. 자바에서는 Sysyem 클래스에 있는 시스템과 관련된 기본 기능들을 제공한다.

표준 입력(System.in), 표준 출력(System.out), 오류 스트림(System.err)등 Java에서 제공해주는 기능들을 사용할 수 있다.

System.out으로 출력했듯이 System.in을 통해서 사용자의 입력을 받을 수 있다. 하지만 System.in을 통해서 사용자 입력을 받으려면 복잡한 과정이 필요하다.

자바에서는 이러한 문제를 해결해주는 Java에서 제공해주는 java.util에 있는 Scanner 클래스를 제공한다.

• Scanner scanner = new Scanner(System.in); new Scanner를 사용해서 스캐너 객체를 생성해 scanner 변수에 저장해주고, Scanner는 System.in을 사용해서 사용자의 입력을 받도록 해준다.

• scanner.nextLine() 엔터(\n)을 입력할 때 까지 문자를 가져오는 기능.

• scanner.nextInt() 입력을 int형으로 가져오는 기능

다음은 간단한 구구단을 입력받아서 출력해주는 프로그램을 작성해보자.

package scanner.ex;

import java.util.Scanner;

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

        Scanner scanner = new Scanner(System.in);
        System.out.print("구구단의 단 수를 입력해주세요: ");
        int dan = scanner.nextInt();

        for(int hang = 1; hang <=9; hang++){
            System.out.println(dan + " x " + hang + " = " + dan * hang);
        }
    }
}

출력 결과

다음 코드에서 분석해 보도록 하자!

public class Scope {
    public static void main(String[] args) {
        int m = 10;
        int temp = 0;
        if (m > 0) {
            temp = m * 2;
        }
        System.out.println("m = " + m);
        System.out.println("temp = " + temp);
    }
}

이 코드는 좋은 코드라고 볼 수 없다. 왜냐하면 temp변수는 if 조건이 만족할 때 임시로 잠깐 사용하는 변수인데 main() 코드 블록에 선언되어 있어서 두 가지 문제가 발생한다.

1. 비효율적인 메모리 사용: temp 는 if 코드 블록에서만 필요하지만, main() 코드 블록이 종료될 때 까지 메모리에 유지된다. 따라서 불필요한 메모리가 낭비된다.

2. 코드 복잡성: temp 는 if 코드 블록 안에서만 필요하고, 여기서만 사용하면 된다. 그렇기 때문에 if 코드 블록안에 선언되었다면, temp에 대한 생각을 더이상 하지 않아도 됐는데 더욱 복잡해 진것으로 볼 수 있다. 비록 지금은 코드가 짧아서 복잡해 보일 수 있지만, 만약 코드가 몇 백줄이라고 생각한다면 Scope를 줄이는게 좋은 코드라고 생각할 것이다.

이제 코드에서 Scope를 줄여보도록 하자!

public class Scope {
    public static void main(String[] args) {
        int m = 10;

        if (m > 0) {
            int temp = 0; // 스코프 줄이기
            temp = m * 2;
            System.out.println("temp = " + temp);
        } // temp 생존 종료
        System.out.println("m = " + m);
    } m 생존 종료
}

extends 키워드는 대상을 하나만 선택할 수 있다.

용어 정리

• 부모 클래스(super class) : 상속을 통해 자신의 필드와 메서드를 다른 클래스에 제공하는 클래스
• 자식 클래스(sub class) : 부모 클래스로부터 필드와 메서드를 상속받는 클래스

상속 관계를 알아보기 위해 자동차를 예를 들어 설명하겠다. 자동차에는 여러가지 종류의 자동차를 볼 수 있다. 전기자동차, 가솔린 자동차 등 추상적인 개념으로 보자면 이들은 모두 "자동차"이고 구체적으로 보면 전기, 가솔린로 볼 수 있다. 이들의 공통점으로는 움직이거나, 브레이크는 공통점으로 묶을 수 있고, 충전방식을 다르게 표현할 수 있다. 이제 이걸 상속으로 표현해 보자면, 움직이는 것을 상속받아서 충전하는 부분을 확장해 나가면 되는 것이다.

코드를 보면서 파악해 보도록 하자.

public class Car {
    public void move() {
        System.out.println("자동차를 움직입니다.")
    }
}

위 코드에서 Cas 클래스는 부모 클래스가 되고, 공통적인 기능은 움직이는 기능 move()가 포함되어 있는 것을 확인할 수 있다.

public class ElectricCar extedns Car() {
    public void charge() {
        System.out.println("자동차를 충전합니다.")
    }
}

위 코드 전기차에서는 extends 키워드를 사용하여 Car 클래스를 상속받고, 덕분에 ElectricCar에서도 move()를 사용할 수 있게 되었다.

public class GasCar extends Car() {
    public void fillup() {
        System.out.println("자동차를 충전합니다.")
    }
}

위 코드에서도 마찬가지로 extends Car를 사용해서 부모 클래스인 Car를 상속 받았고, 여기서도 move()를 사용할수 있게 되었다.

상속 구조도 위 사진에서 화살표 방향을 주의해서 살펴보자. 화살표 방향이 이렇게 생긴 이유는 자식 클래스는 부모 클래스로부터 기능을 물려 받아서 접근이 가능하지만, 부모 클래스 입장에서는 누가 상속을 받는지도 모르고 부모 클래스에서 자식 클래스로 접근을 할 수 없기 때문에 방향이 자식 클래스에서 가리키게 된 것이다.

참고로 자바는 다중 상속이 불가하다!!

만약 다중 상속이 된다고 생각하면 어떤 일이 벌어지게 될까? 부모 클래스를 2개 상속받는다고 생각해보자. 만약 부모 클래스의 move()기능이 둘 다 있다면 과연 자식 클래스 입장에서는 어떤 부모의 move()를 사용해야 할지 애매한 문제가 발생하게 된다. 이것을 다이아몬드 문제라고 한다. 다중 상속을 하게 되면 이와 같은 애매한 문제와 클래스 계층 구조가 매우 복잡해 질 수 있다. 이런 문제점들 때문에 자바에서는 클래스의 다중 상속을 허용하지 않는다.

상속과 메모리 구조

상속 부분에 있어서 제일 중요하다고 생각하는 부분이 바로 메모리 구조를 파악하는 것이라고 생각한다.

ElectricCar electriCar = new ElectriCar();

위 코드 부분에서 new ElectriCar()를 호출하면 ElectriCar뿐만 아니라 상속 관계에 있는 Car 까지 함께 포함해서 인스턴스를 생성한다. 참조값은 x001로 하나이지만 실제로 그 안에서는 ElectriCar하고 Car두 클래스의 정보가 함께 들어있다는 것이다. 상속이라고 해서 단순하게 부모의 필드와 메서드만을 물려받는 것이 아니라 클래스도 함께 포함해서 생성되는 것이다. 겉으로 보기에는 하나의 인스턴스를 생성하는 것 처럼 보일 수 있지만 실제로는 부모와 자식이 모두 생성되고 공간도 구분되어 있는 것이다.

electricCar.charge()

electricCar.charge()를 호출하면 참조값인 x001을 확인해서 x001.charge()를 호출한다. 상속 관계의 경우에는 내부에 부모 클래스, 자식 클래스 모두가 존재하기 때문에 접근을 어디에 먼저 할 지를 선택해야 한다. 이때는 호출하는 변수의 타입을 기준으로 선택한다. elecricCar의 변수의 타입이 ElectricCar이기 때문에 인스턴스 내부에 같은 타입은 ElectricCar를 통해서 charge()를 호출한다.

electricCar.move()

그렇다면 electricCar.move()를 호출하면 어떻게 되는 걸까? 먼저 electricCar.move()룰 호출하게 된다면 참조값인 x001로 먼저 이동하게 된다. 호출하는 변수의 타입은 ElecticCar이기 때문에 타입에 맞게 선택하게 된다. 하지만 ElectricCar에는 move()라는 메서드가 없기 대문에 부모타입으로 올라가서 찾게 된다. 부모 타입인 Car로 올라가서 move()가 있는지 확인후 move()가 있기 때문에 부모에 있는 move()를 호출하게 된다.

만약 부모에서도 해당 기능을 찾지 못하게 된다면 더 상위 부모로 찾아가게 된다. 계속 올라갔는데도 찾지 못한다면 컴파일 오류를 발생하게 된다.

상속과 메모리에서 중요한 3가지를 요약해 보았다.

• 상속 관계인 객체를 생성하면 그 내부에는 부모, 자식 모두 생성된다.
• 상속 관계인 객체를 호출할 때, 대상 타입을 정하고, 이때 호출자의 타입을 통해 대상 타입을 찾는다.
• 만약 현재 타입에서 기능을 찾지 못한다면, 부모 타입으로 이동하게 되고, 그래도 못찾게 된다면 컴파일 오류를 발생시킨다.

public class FieldInit {
 static final int CONST_VALUE = 10;
 final int value = 10;
}

• 위 코드처럼 value값을 초기화 하는 경우, 모든 인스턴스가 오른쪽 힙 영역 그림과 같이 모든 인스턴스에 value는 10을 가지게 된다.
• 모든 인스턴스가 같은 값을 사용하기 때문에 결과적으로는 메모리를 낭비하게 된다. 또한 값이 계속 생성되는 것은 개발자가 보기에는 중복으로 보인다!

바로 이럴 때 사용하는 것이 static final을 같이 사용하는 것이다.

MY_VALUE는 static영역에 존재하고, final 키워드를 사용했기 때문에 값이 변하지 않게된다. 즉 static영역은 단 하나만 존재하기 때문에 MY_VALUE변수는 JVM에서 하나만 존재하기 때문에 메모리를 보다 더 효율적으로 사용할 수 있게 되었다.

• 메서드 영역 : 클래스 정보(실행코드), 필드, 메서드와 생성자 등 모든 코디가 존재한다. 또한 static 영역과 상수들을 관리한다.

• 스택 영역 : 실제 프로그램이 실행되는 영역으로 자바 실행 시, 하나의 실행 스택이 생성된다. 각 스택 프레임은 지역 변수, 메서드 호출 정보 들을 포함한다.

• 힙 영역 : 객체(인스턴스)가 생성되는 영역이다. new명령어를 사용하면 힙 영역을 사용하게 된다. 만약 참조되지 않는 객체가 있다면 가비지컬렉터에 의해 제거된다.

  힙 영역에는 만약 객체가 100개 생성된다면 힙 메모리에 100개의 객체(인스턴스)가 생기게 된다. 같은 클래스로 부터 생성된 객체라도, 인스턴스 내부의 변수 값은 서로 다를 수 있지만, 메서드는 공통된 코드를 공유한다. 따라서 메서드는 메서드 영역에서 공통으로 관리되고 실행된다.

멤버 변수와 메서드의 매개변수의 이름이 같으면 둘은 어떻게 구분해야 할까? 먼저 코드를 보도록하자. 다음 코드는 학생 객체를 생성하는 프로그램이다.

package construct;
public class StudentInformation {
 String name;
 int age;
 int grade;


 public StudentInformation(String name, int age, int grade) {
 name = name;
 age = age;
 grade = grade;
 }
}

위 코드에서 생성자를 보면 멤버 변수와 생성자의 매개변수 이름이 같은 것을 볼 수 있다. 과연 어떻게 구분해야 할까?

• 이 경우에는 멤버 변수보다 매개변수의 코드가 코드 블럭의 더 안쪽에 있기 때문에 매개변수가 우선순위를 가진다. 따라서 StudentInformation(String name, ...) 생성자 안에서 name이라고 적으면 매개변수에 접근하게 된다.
• 멤버 변수에 접근하려면 앞에 this. 이라고 붙여주면 된다. this는 인스턴스(객체) 자신의 참조값을 가리킨다. 이렇게 생각하면 this를 왜 사용하는지 알게 되었을 것이다.

> 코드를 다음과 같이 변경해주면 된다.

package construct;
public class StudentInformation {
 String name;
 int age;
 int grade;


 public StudentInformation(String name, int age, int grade) {
 this.name = name;
 this.age = age;
 this.grade = grade;
 }
}

> 그렇다면 과연 this()는 무엇일까?

메소드 오버로딩을 하는 것 처럼 생성자도 매개변수만 다르게 해서 여러 생성자를 제공할 수 있다.

package construct;
public class StudentInformation {
 String name;
 int age;
 int grade;

 public StudentInformation(String name, int age){
 this.name = name;
 this.age = age;
 this.grade = 0;
 }

 public StudentInformation(String name, int age, int grade) {
 this.name = name;
 this.age = age;
 this.grade = grade;
 }
}

위에 코드를 보면 반복되는 부분을 찾을 수 있다.

 this.name = name;
 this.age = age;

개발자가 제일 싫어하는 것이 무엇인가? 바로 중복코드이다!! 이때 this()라는 기능을 사용하면 생성자 내부에서 자신의 생성자를 호출할 수 있다. 참고로 this는 인스턴스 자신의 참조값을 가리킨다. 따라서 자신의 생성자를 호출한다고 생각하면 된다. 이제 코드를 수정해 보도록 하자.

package construct;
public class StudentInformation {
 String name;
 int age;
 int grade;

 public StudentInformation(String name, int age){
 this(name,age,0);
 }
 /
 public StudentInformation(String name, int age, int grade) {
 this.name = name;
 this.age = age;
 this.grade = grade;
 }
}

this()를 사용하면 생성자 내부에서 다른 생성자를 호출 할 수 있다. 첫번째 생성자에서 두번째 생성자를 호출한 것이다. 이 부분을 잘 활용한다면 지금과 같은 중복코드를 제거할 수 있다.

this()를 사용하려면 주의사항이 있다. 명심하도록 하자.

this()는 생성자 코드의 첫줄에만 작성이 가능하다. 다음은 컴파일 에러가 발생하는 코드이다.

System.out.println("에러가 발생하는 코드입니다.);
public StudentInformation(String name, int age){
 this(name,age,0);