개발계발

[MSA 프로젝트] AWS S3 연결하기

Ju_Nik_E — Fri, 19 Jul 2024 16:25:12 +0900

어려운 건 아니지만 프로젝트를 진행하면서 AWS S3 연결할 때마다 방법을 까먹어서 기록해놓기

1. 의존성 추가

//s3
	implementation 'org.springframework.cloud:spring-cloud-starter-aws:2.2.6.RELEASE'

2. yml파일 aws관련 코드 작성

cloud:
  aws:
    stack:
      auto: false
    region:
      static: AWS지역
    credentials:
      access-key: 액세스키
      secret-key: 비밀키
    s3:
      bucket: 버킷명

3. S3Config 파일 작성

import com.amazonaws.auth.AWSStaticCredentialsProvider;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class S3Config {

    @Value("${cloud.aws.credentials.access-key}")
    private String accessKey;

    @Value("${cloud.aws.credentials.secret-key}")
    private String secretKey;

    @Value("${cloud.aws.region.static}")
    private String region;

    @Bean
    public AmazonS3 amazonS3Client() {
        BasicAWSCredentials credentials = new BasicAWSCredentials(accessKey, secretKey);

        return AmazonS3ClientBuilder
                .standard()
                .withRegion(region)
                .withCredentials(new AWSStaticCredentialsProvider(credentials))
                .build();
    }
}

4. S3Serivce 파일 작성(기본적으로 파일 업로드, 삭제기능, 필요 시 추가)

import com.amazonaws.services.s3.AmazonS3;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;

@Service
@RequiredArgsConstructor
public class S3Service {
    private final AmazonS3 amazonS3Client;

    @Value("${cloud.aws.s3.bucket}")
    private String bucket;

    public String uploadFile(String fileName, MultipartFile file) throws IOException {
        amazonS3Client.putObject(bucket, fileName, file.getInputStream(), null);
        return amazonS3Client.getUrl(bucket, fileName).toString();
    }

    public void deleteFile(String fileName) {
        amazonS3Client.deleteObject(bucket, fileName);
    }
}

5. 아래와 같이 서비스 코드에 S3Service 주입하고 사용하면 끝!

@Slf4j
@Service
@RequiredArgsConstructor
public class LectureNoteService {
    private final LectureNoteRepository lectureNoteRepository;
    private final S3Service s3Service;
    
    /**
     * 강의 노트 등록
     */
    @Transactional
    public LectureNoteResponseDto create(Long lectureId, String title, MultipartFile file) {
        String fileUrl;
        try {
            String fileName = "lecture-notes/" + UUID.randomUUID() + "-" + file.getOriginalFilename();
            fileUrl = s3Service.uploadFile(fileName, file);
        } catch (IOException e) {
            throw new CustomException(ErrorCode.FILE_UPLOAD_FAILED);
        }

        LectureNote lectureNote = LectureNote.builder()
                .lectureId(lectureId)
                .title(title)
                .fileUrl(fileUrl)
                .build();

        LectureNote savedLectureNote = lectureNoteRepository.save(lectureNote);

        return LectureNoteResponseDto.builder()
                .noteId(savedLectureNote.getNoteId())
                .lectureId(savedLectureNote.getLectureId())
                .title(savedLectureNote.getTitle())
                .fileUrl(savedLectureNote.getFileUrl())
                .build();
    }
}

[MSA 프로젝트] 각 서비스끼리 통신하기 만들기

Ju_Nik_E — Fri, 19 Jul 2024 16:19:23 +0900

MSA 구조 프로젝트를 진행하던 중 각 서비스끼리 통신하는 방법에 대해 기록해놓으려고 한다.

WebClient와 FeignClient, 크게 두 가지 방법이 있다.

내가 프로젝트에 적용한 것은 FeignClient이지만, 두 가지 방법 모두 기록해놓자.

WebClient

웹클라이언트를 사용하려면 아래 과정을 따라가면 된다.(의존성 파일에 spring-boot-starter-webflux가 추가필요)

1. Bean 등록

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.reactive.function.client.WebClient;

@Configuration
public class WebClientConfig {

    @Bean
    public WebClient.Builder webClientBuilder() {
        return WebClient.builder();
    }
}

2. 요청 작성(Get, Post요청 예시)

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Mono;

@Service
public class MyService {

    @Autowired
    private WebClient.Builder webClientBuilder;

    public String getExample() {
        WebClient webClient = webClientBuilder.build();
        Mono<String> response = webClient.get()
            .uri("http://example.com/api/resource")
            .retrieve()
            .bodyToMono(String.class);

        return response.block();
    }
    
    public String postExample() {
        WebClient webClient = webClientBuilder.build();
        MyRequestObject request = new MyRequestObject("data1", "data2");
        Mono<String> response = webClient.post()
            .uri("http://example.com/api/resource")
            .bodyValue(request)
            .retrieve()
            .bodyToMono(String.class);

        return response.block();
    }
}

여기까지가 WebClient 사용법인데, 요청의 상세내용을 메서드로 상세하게 작성해줘야하는 번거로움이 있다.

이에 반해 FeignClient는 인터페이스를 이용해 선언적 방식으로 아주 간단하게 요청을 보낼 수가 있다.

FeignClient

feignClient를 이용하기위해선 우선 의존성 추가가 필요하다.

    implementation 'org.springframework.cloud:spring-cloud-starter-openfeign:4.1.0'

*버전은 사용중인 스프링부트 버전과 호환되는 지 잘 확인하자

이후 FeignClient 어노테이션을 이용해 아래와 같이 코드를 작성하면 된다.

package com.jk.module_lecture.client;

import com.jk.module_lecture.common.config.FeignConfig;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

@FeignClient(name = "lectureResourceClient", url = "${feign.lectureResourceClient.url}", configuration = FeignConfig.class)
public interface LectureResourceClient {

    @RequestMapping(method = RequestMethod.POST, value = "/api/v1/internal/lectures/notes", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
    void createNote(@RequestPart("file") MultipartFile file, @RequestParam("lectureId") Long lectureId, @RequestParam("title") String title);

    @RequestMapping(method = RequestMethod.POST, value = "/api/v1/internal/lectures/multimedia", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
    void createVideo(@RequestPart("file") MultipartFile file, @RequestParam("lectureId") Long lectureId);

    @RequestMapping(method = RequestMethod.GET, value = "/api/v1/internal/lectures/notes/{lectureId}", consumes = "application/json")
    String getNoteUrl(@PathVariable("lectureId") Long noteId);

    @RequestMapping(method = RequestMethod.GET, value = "/api/v1/internal/lectures/multimedia/{lectureId}", consumes = "application/json")
    String getVideoRul(@PathVariable("lectureId") Long videoId);
}

위에 작성한 인터페이스를 사용하는 예시 코드는 아래와 같다.

@Slf4j
@Service
@RequiredArgsConstructor

public class LectureService {
	private final LectureRepository lectureRepository;
	private final LectureResourceClient lectureResourceClient;
    
    
    /**
     * 강의 등록
     */
    @Transactional
    public LectureCreateResponseDto create(Long teacherId, LectureCreateRequestDto lectureCreateRequestDto) {
        Lecture lecture = Lecture.builder()
                .title(lectureCreateRequestDto.title())
                .description(lectureCreateRequestDto.description())
                .teacherId(teacherId)
                .price(lectureCreateRequestDto.price())
                .build();

        Lecture savedLecture = lectureRepository.save(lecture);

        lectureResourceClient.createNote(
                lectureCreateRequestDto.file(),
                savedLecture.getLectureId(),
                savedLecture.getTitle()
        );

        lectureResourceClient.createVideo(
                lectureCreateRequestDto.video(),
                savedLecture.getLectureId()
        );

        return LectureCreateResponseDto.builder()
                .lectureId(savedLecture.getLectureId())
                .title(savedLecture.getTitle())
                .description(savedLecture.getDescription())
                .teacherId(savedLecture.getTeacherId())
                .price(savedLecture.getPrice())
                .build();
    }
}

위와 같이 서비스 코드에 lectureResourceClient를 주입받아와 간단하게 요청을 보낼 수 있게 된다.

해당 요청을 받는 서비스 모듈은 InternalController api주소를 생성해서 받으면 된다.

@RestController
@RequiredArgsConstructor
@RequestMapping("/api/v1/internal/lectures/notes")
public class InternalLectureNoteController {
    private final LectureNoteService lectureNoteService;
    
    @PostMapping(consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
    public ResponseEntity<Void> createNote(
            @RequestPart(name = "file") MultipartFile file,
            @RequestParam(name = "lectureId") Long lectureId,
            @RequestParam(name = "title") String title
    ) {
        lectureNoteService.create(lectureId, title, file);
        return ResponseEntity.ok().build();
    }
    
}

내부적으로 데이터를 주고 받는 것이기 때문에, 요청/응답에 대한 상세내용 또한 외부로 알릴 필요가 없어, WebClient보다 훨씬 간단하게 사용가능한 FeignClient를 사용하자.

배열에서 중복을 제거하는 법

Ju_Nik_E — Thu, 13 Jun 2024 22:59:19 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/120852

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

위 문제를 풀다가 answer를 반환할 때 중복을 제거하는 방법에서 막힘

원래 내가 제출한 코드는

def solution(n):
    answer = []
    divide_num = 2
    while divide_num <= n:
        if n % divide_num == 0:
            answer.append(divide_num)
            n = n / divide_num
        else:
            divide_num += 1
    return list(set(answer))

위와 같았는데, set은 중복은 제거하나, 순서를 보장하지 않아서 틀렸다고 나옴.

그래서 dict을 써서 아래와 같이 중복을 제거하고 순서도 보장해주는 아래와 같이 변경함.

def solution(n):
    answer = []
    divide_num = 2
    while divide_num <= n:
        if n % divide_num == 0:
            answer.append(divide_num)
            n = n / divide_num
        else:
            divide_num += 1
    return list(dict.fromkeys(answer))

결론

list(dict.fromkeys(answer))

위 코드 잘 기억하자

프로그래머스 - 3진법 뒤집기(68935)

Ju_Nik_E — Fri, 17 May 2024 09:24:15 +0900

문제링크

https://school.programmers.co.kr/learn/courses/30/lessons/68935

프로그래머스

programmers.co.kr

접근방식

1. 입력값 n을 3으로 나눈 나머지를 3진법으로 변환한 코드에 넣는다.

2. n을 3으로 나눈 몫으로 바꾼다.

3. 위 과정을 n이 0이 될 때까지 반복한다.

풀이코드

def solution(n):
    answer = 0
    formation_3 = ""
    # i = 1
    
    while n > 0:
        formation_3 += str(n % 3)
        n = n // 3
        
    # for j in range(len(formation_3)-1, -1 ,-1):
    #     answer += i * int(formation_3[j])
    #     i *= 3

    answer = int(formation_3, 3)
    
    return answer

알아두면 좋은 것

- 위 코드에 while문 블록에 있는 3을 다른 숫자로 바꾸면 그대로 [해당 숫자진법]이 된다.(단, 변환 결과가 거꾸로 나오니 다시 뒤집어줘야함, 이 문제는 애초에 뒤집어서 반환하는 거라 안 뒤집엇음)

- int함수의 2번째 매개변수로 숫자를 주면 첫번째 매개변수를 해당 숫자진법으로 해석하고 10진법으로 변환해줌

프로그래머스 - 큰 수 만들기(42883)

Ju_Nik_E — Thu, 16 May 2024 15:24:18 +0900

문제 링크

https://school.programmers.co.kr/learn/courses/30/lessons/42883

프로그래머스

programmers.co.kr

접근 방식1 (틀림)

1. 입력값인 number를 정렬

2. 정렬된 값에서 순서대로 작은 숫자 k를 삭제한다.

3. 값을 지우고 남은 숫자들을 원래 순서대로 다시 조합한다.

풀이 코드1 (틀림)

def solution(number, k):
    answer = ''
    numbers = []
    
    for idx, num in enumerate(number):
        numbers.append((idx, int(num)))
        
    numbers.sort(key = lambda x : (x[1], x[0]), reverse = True)
    
    for _ in range(k):
        numbers.pop()
        
    numbers.sort(key = lambda x : x[0])
        
    for i in range(len(numbers)):
        answer += str(numbers[i][1])
        
    return answer

- 문제의 1, 2번 예시는 맞는데 3번 예시는 틀림

-> 작은수를 k개 빼는 게 아니라 자릿수의 대소관계를 생각해야 함.

접근방식 2 (시간초과)

1. number의 맨 앞자리와 바로 뒷자리를 비교

2. 앞자리가 더 작을경우 삭제

3. 위 과정을 k번 반복

4. 앞자리가 더 작은 경우가 없으면 number의 맨 뒤 숫자 삭제

풀이코드 2 (로직은 맞음, 시간초과)

def solution(number, k):
    answer = ''
    front_num = ''
    back_num = ''
    
    # i가 i+1보다 커야만 함, 작으면 지워져야함
    for count in range(k):
        for i in range(len(number)-1):
            if int(number[i]) < int(number[i+1]):
                front_num = number[:i]
                back_num = number[i+1:]
                number = front_num + back_num
                break
        else:
            number = number[:-1]
            
    return number

- 로직은 맞는데, 시간초과가 남

- stack을 이용한 아래 코드로 개선

풀이코드3 (정답)

def solution(number, k):
    answer = ''
    stk = []
    
    for num in number:
        while stk and stk[-1] < num and k > 0:
            stk.pop()
            k -= 1
        stk.append(num)
    
    answer = "".join(stk)
    
    if k > 0:
        answer = answer[:-k]
    
    return answer

주의사항

- number가 "333222111"처럼 맨 앞에서 맨 뒤까지 계속해서 같거나 작아지는 경우만 있는 경우 while을 들어가지 못함

--> 이런 경우 맨 뒷자리를 지우면 되기 때문에 남은 k만큼 뒤를 지워주면 됨

프로그래머스 - 기사단원의 무기(136798)

Ju_Nik_E — Thu, 16 May 2024 15:13:42 +0900

문제 설명

https://school.programmers.co.kr/learn/courses/30/lessons/136798

프로그래머스

programmers.co.kr

접근 방식

1. [1~number]까지의 약수의 갯수를 모두 구해서 리스트에 저장

1-1. 약수의 갯수가 limit보다 크면 리스트에 약수의 갯수 대신 power를 넣음

2. 리스트의 합 구해서 반환

풀이 코드1(정답)

def count_divisors(number, limit):
    if number == 1:
        return 1
    
    result = 0
    
    for num in range(1, int(number**(1/2)) + 1):
        if number % num == 0:
            if num * num == number:
                result += 1
            else:
                result += 2
            
            if result > limit:
                return 0
    
    return result

def solution(number, limit, power):
    answer = 0
    divisors = []
    for num in range(1, number+1):
        result = count_divisors(num, limit)
        if result == 0:
            divisors.append(power)
        else:
            divisors.append(result)
        
    return sum(divisors)

- 약수의 갯수를 구할 때 for문의 범위를 해당 숫자의 제곱근 + 1 까지로 하지 않으면 시간초과가 난다.

- 같은 수끼리 곱했을 때는 1만 더해주고 아닐 경우에는 2씩 더해주면 된다

ex) 16의 약수의 갯수를 구할 때 for문의 범위는 (제곱근+1)인 5까지로 하고,

1*16 일때는 1과 4, 약수가 2개 구해지기때문에 약수의 갯수에 2를 더해주고,

4*4 일때는 약수가 1개이기 때문에 약수의 갯수에 1을 더해준다.

풀이 코드2 (스터디원의 풀이, 약수 구하는 시간 복잡도 개선)

def solution(number, limit, power):
    divisor_count = [0] * (number + 1)
    
    for i in range(1, number + 1):
        for j in range(i, number + 1, i):
            divisor_count[j] += 1
            
    for idx in range(1, number + 1):
        if divisor_count[idx] > limit:
            divisor_count[idx] = power
            
    return sum(divisor_count)

1. 약수의 갯수를 저장할 리스트를 초기화한다.

2. 2중 for문으로 리스트를 도는데, 안쪽 for문은 i씩(i의 배수) 커지도록 한다.

프로그래머스 - 행렬의 곱셈(12949)

Ju_Nik_E — Fri, 3 May 2024 09:43:38 +0900

문제 설명

2차원 행렬 arr1과 arr2를 입력받아, arr1에 arr2를 곱한 결과를 반환하는 함수, solution을 완성해주세요.

제한 조건

- 행렬 arr1, arr2의 행과 열의 길이는 2 이상 100 이하입니다.
- 행렬 arr1, arr2의 원소는 -10 이상 20 이하인 자연수입니다.
- 곱할 수 있는 배열만 주어집니다.

접근 방식

- 행렬의 곱셈 공식을 알아야 함

- a*b 크기의 행렬과 c*d 크기의 곱셈의 결과 행렬의 크기는 a*d이다.

- 첫째 행렬의 열 갯수와 둘째 행렬의 행 갯수가 동일해야한다.

- 곱셈한 결과의 1행의 0번 인덱스는

[첫번째 행렬의 (0,0) 원소 * 두번째 행렬의 (0,0) 원소] + [첫번째 행렬의 (0,1) 원소 * 두번째 행렬의 (1,0) 원소]

-> 즉, 첫번째 행렬은 행의 인덱스(x)가 증가, 두번째행렬은 열의 인덱스(y)가 증가

1. [arr2의 안에 1차원 배열의 크기 * arr2의 1차원 배열의 크기] 의 배열 생성

2. 첫번째 행렬의 y값이 1씩 증가하고, 두번째 행렬의 x값이 1씩 증가하도록 중첩 for문 구현

정답 코드

def solution(arr1, arr2):
    answer = [[0] * len(arr2[0]) for _ in range(len(arr1))]
    
    for i in range(len(arr1)):
        for j in range(len(arr2[0])):
            for k in range(len(arr2)):
                answer[i][j] += arr1[i][k] * arr2[k][j]
    
    return answer

인터페이스의 타입 변환과 다형성

Ju_Nik_E — Thu, 2 May 2024 16:46:25 +0900

타입 변환

인터페이스의 타입 변환은 인터페이스와 구현 클래스 간에 발생한다.
자동 타입 변환과 강제타입 변환이 있는데, 인터페이스 변수에 구현 객체를 대입하면 구현 객체는 인터페이스 타입으로 자동 타입 변환되고, 인터페이스 타입을 구현 클래스로 타입으로 변환시킬 때는 강제 타입 변환이 필요하다.

자동 타입 변환

말 그대로 자동으로 타입 변환이 일어나는 것으로, 아래와 같은 조건에서 일어난다.
인터페이스 변수 = 구현객체;

위 이미처럼 인터페이스를 구현한 B, C 클래스가 있고, B와 C클래스를 각각 상속한 D, E 자식 클래스가 있을 때,

B,C,D,E로부터 생성된 객체는 모두 인터페이스 A로 자동 타입 변환이 가능하다.

B,C,D,E가 클래스가 모두 작성됐다고 가정하면 아래와 같이 자동 타입 변환이 가능하다.

public class PromotionExample {
	public static void main(String[] args) {
    	//구현 객체 생성
        B b = new B();
        C c = new C();
        D d = new D();
        E e = new E();
        
        //인터페이스 변수
        A a;
        
        //자동 타입 변환
        a = b;
        a = c;
        a = d;
        a = c;
    }
}

위 예시처럼, 구현 객체인 b,c,d,e의 타입은 모두 A로 타입변환이 가능하다.

강제 타입 변환

강제 타입 변환은 캐스팅 기호를 이용해 인터페이스 타입을 구현 클래스 타입으로 변환시키는 것이다.
구현 클래스 변수 = (구현클래스) 인터페이스변수;

구체적인 사용예시는 아래와 같다.

public interface Vehicle {
	// 추상 메소드
    void run();
}

public class Bus implements Vehicle {
	// 추상 메소드 재정의
	@Override
    public void run() {
    	System.out.println("버스 운행 시작");
    }
    
    // 추가 메소드
    public void checkFare() {
    	System.out.println("요금 확인");
    }
}

public class CastingExample {
	public static void mian(String[] args) {
    	// 인터페이스에 구현 객체를 대입해 자동 타입 변환
    	Vehicle vehicle = new Bus();
        
        // 인터페이스의 메소드 사용
        vehicle.run();
        // vehicle.checkFare(); 자동타입변환되어 Bus클래스의 추가 메소드 사용 불가
        
        // 강제 타입변환
        Bus bus = (Bus) vehicle;
        bus.checkFare(); // 강제타입 변환을 했기 때문에 사용 가능
    }
}

다형성

사용 방법은 동일하지만 다양한 결과가 나오는 성질인 다형성은 상속에서도 사용하지만, 인터페이스를 통해 다형성을 구현하는 경우가 많다.

위 그림에서 객체B와 C중 어느 객체가 인터페이스에 대입됐냐에 따라 객체 A의 메소드 호출 결과가 달라질 수 있다.

아래의 코드예시를 보자.

public interface Tire {
	void roll();
}

public class HankookTire implements Tire {
	// 메소드 재정의
    @Override
    public void roll() {
    	// 한국 타이어
    }
}

public class KumhoTire implements Tire {
	// 메소드 재정의
    @Override
    public void roll() {
    	// 금호 타이어
    }
}

public class Car {
	//필드
    Tire tire1 = new HankookTire();
    Tire tire2 = new HankookTire();
    
    //메소드
    void run() {
    	tire1.roll();
        tire2.roll();
    }
}

public class CarExample {
	public static void main(String[] args) {
    	// 객체 생성
    	Car myCar = new Car();
        
        // run()메소드 실행
        myCar.run();
        
        // 타이어 객체 교체
        myCar.tire1 = new KumhoTire();
        
        // 다형성으로 인해 결과 변경
        myCar.run();
    }
}

다중 인터페이스 구현

Ju_Nik_E — Thu, 2 May 2024 16:16:23 +0900

이전에 인터페이스에 대해 포스팅했는데, 구현 객체는 여러 개의 인터페이스를 implements할 수 있다.
사용법은 아래와 같다.

public class 구현클래스 implements 인터페이스1, 인터페이스2 {

}

이 경우, 구현 클래스는 여러 개의 인터페이스의 추상 메소드를 모두 재정의 해야한다.

인터페이스 상속

자바의 클래스는 다중 상속을 허용하지 않으나, 인터페이스는 다중 상속이 허용된다.
사용법은 아래와 같다.

public interface 자식인터페이스 extends 부모인터페이스1, 부모인터페이스2 {
	...
}

이 경우, 이 자식인터페이스의 구현 클래스는 자식 인터페이스와 모든 부모 인터페이스의 모든 추상 메소드를 재정의해야 한다.

단, 구현 객체를 부모 인터페이스 변수에 대입할 경우, 자식 인터페이스의 추상 메소드는 호출 불가능하다.

아래 예시를 보자

public interface InterfaceA {
	void methodA();
}

public interface InterfaceB {
	void methodB();
}

public interface InterfaceC extends InterfaceA, InterfaceC {
	void methodC();
}

public class InterfaceCImple implements InterfaceC {
    // 추상 메소드 재정의
	public void methodA() {
    	
    }
    
    public void methodB() {
    	
    }
    
    public void methodC() {
    	
    }
}

public class ExtendsExample {
	public static void main(String[] args) {
    	InterfaceCImpl impl = new InterfaceCImpl();
        
        //부모 인터페이스 변수에 대입
        InterfaceA ia = impl;
        ia.methodA();
        // ia.methodB(); 사용불가
        // ia.methodC(); 사용불가
        
        InterfaceB ia = impl;
        // ib.methodA(); 사용불가
        ib.methodB();
        // ib.methodC(); 사용불가
        
        InterfaceC ic = impl;
        ic.methodA();
        ic.methodb();
        ic.methodc();
    }
}

인터페이스

Ju_Nik_E — Thu, 2 May 2024 15:18:31 +0900

인터페이스란?

두 객체를 연결하는 역할을 하는 것으로, 인터페이스를 통해 객체가 다른 객체를 직접 사용하지 않음으로 다형성 구현에 주된 기술로 이용된다.

예를 들어, 아래와 같이 객체 B가 객체 C로 변경된다 하더라도, 객체 A는 인터페이스의 메소드만 사용하기 때문에 아무 상관이 없다.

인터페이스 선언

인터페이스는 class 키워드 대신 interface 키워드를 사용한다.(파일 자체는 클래스와 동일하게 .java의 형태)

interface 인터페이스명 {...} // default 접근 제한

// public 접근 제한
public interface 인터페이스명 {
	// public 상수 필드
    // public 추상 메소드(선언부만 있고, 실행부인 중괄호가 없는 메소드)
    // public 디폴트 메소드
    // public 정적 메소드
    // private 메소드
    // private 정적 메소드
}

그럼 구체적으로 인터페이스를 사용하는 예시를 살펴보자

메인(사람)이 인터페이스(리모컨)을 이용해 객체(티비)를 조작하는 예시이다.

// 인터페이스
public interface RemoteControl {
	// 추상 메소드
    public void turnOn();
}

// 객체1
public class Television implements RemoteControl {
	@Override
    public void turnOn() {
    	System.out.println("tv를 킨다.)
    }
}

// 객체2
public class Audio implements RemoteControl {
	@Override
    public void turnOn() {
    	System.out.println("오디오를 킨다.)
    }
}

// 메인
public class RemoteControlExample {
	public static void main(String[] args) {
    	RemoteControl rc;
        
        // rc변수에 Television 객체 대입
        rc = new Television();
        rc.turnOn();
        
        // rc변수에 Audio 객체 교체
        rc = new Audio();
        rc.turnOn();
    }
}

위의 예시처럼 인터페이스는 추상메소드를 가지고 있고, Television 클래스와 Audio 클래스는 인터페이스를 상속받아서, 인터페이스의 메소드와 같은 이름의 메소드를 Override해서 사용할 수 있다.

이렇게 되면 메인 클래스(사람)은 RemoteControl 인터페이스를 통해 Television과 Audio를 자유롭게 사용할 수 있다.

주의사항

어떤 인터페이스를 상속받은 클래스는 반드시 해당 인터페이스에 정의된 모든 추상 메소드를 재정의해야한다.

인터페이스의 필드

인터페이스는 public static final특성을 갖는 불변의 상수 필드만을 멤버로 가질 수 있다.
public static final 타입 변수명 = 값;
public static final 키워들르 생략해도 컴파일 과정에서 자동으로 붙는다. 아래와 같이 선언할 수 있다.

public interface RemoteControl {
	int MAX_VOLUME = 10;
    public static final int MIN_VOLUME= 0;
    
    // 둘다 같은 접근 제한을 갖게 됨
}

상수는 구현 객체와 상관없이 인터페이스 소속 멤버이므로 인터페이스로 바로 접근해 사용 가능하다.

public class RemoteControlExample {
	public static void main(String[] args) {
    	System.out.println("리모콘 최대 볼륨: " + RemoteControl.MAX_VOLUME);
    }
}

디폴트 메소드

인터페이스에는 추상메소드 외에도 완전한 실행 코드를 갖는 디폴트 메소드를 선언할 수 있다.
바로 아래의 예시를 보자

public interface RemoteControl {
	// 추상 메소드
    void setVolume(int volume);
	
	// 디폴트 인스턴스 메소드
    default void setMute(boolean mute) {
    	if(mute) {
      		System.out.println("무음 설정");
        	setVolume(MIN_VOLUME);
        } else {
        	System.out.println("무음 해제");
        }
    }
}

정적 메소드

구현 객체없이 인터페이스에 직접 접근해 사용할 수 있는 정적 메소드도 선언가능하다.
아래의 예시를 보자

public interface RemoteControl {
	// 정적 메소드
    static void changeBattery() {
    	System.out.println("건전지 교체")
    }
}

주의사항 : 정적메소드는 실행부에 상수필드를 제외한 추상 메소드, 디폴트 메소드, private 메소드 등을 호출할 수 없다.(이 메소드들은 구현 객체가 필요한 인스턴스 메소드이기 때문)

private 메소드

인터페이스의 상수 필드, 추상 메소드, 디폴트 메소드, 정적 메소드는 모두 public의 접근 제한을 갖는다.
선언할 때 public 키워드를 생략해도 컴파일 과정에서 public 접근 제한자가 자동으로 붙는데,
private 키워드를 명시해줌으로써 private 접근제한을 갖는 메소드를 선언할 수 있다.(외부에서 접근 불가능)